When I was probably 9 or 10 (for reference, I'm 21), I remember playing Minecraft with my dad on our Xbox. I was a bright kid, and loved toying with redstone, so our world was filled with the random redstone projects I'd started, and very few I'd finished. I can still remember my dad asking me one simple question:\n> Why don't you ever finish the projects you start? \n\nI didn't have a good answer. I did make it my mission to complete the project I was working on then (a waterslide with levers at the bottom and top, using an XNOR gate so no matter which lever I flipped, the state would change), and I did. This was the first time I remember taking notice of my habit to do things halfway. It wasn't out of an inability to do the tasks; I just had (and have) so many ideas that I lose direction, and try to do all of them.\n\nThis is frustrating for a lot of reasons, especially when it comes to my professional development. My GitHub is littered with half finished projects that are set to private, and a few that are public as a way to motivate myself to continue working on them. I have a research paper on climate change sitting unfinished on my computer, and a Medium post in my drafts with a less academic version of the same content.\n\nIn my life as a young adult, I came to find out I have ADHD. This made a lot of sense and cleared things up, but I was still left with the feeling of not knowing how to maintain dedication to my projects without jumping around. So, how can we mitigate the negative effects of ADHD while capitalising on the strengths it gives? This is a question that I sat on for a while, and I don't think that there is a one-size-fits-all solution. However, there are definitely some tips that have worked for me as well as for many other adults (and kids/teens) with and without ADHD.\n\n---\n\n# Find Methods That Help You Focus\nI know this seems silly, and the title is a bit. But I promise I'm gonna go more in-depth than just this. The first tip is to experiment. You won't get anywhere by blindly following lists and hoping they work. You need to experiment with various methods and use what works for you; what works for you might not work for everyone else. When I would ask my dad for advice on staying on task, he always had the same answer: \\\"discipline\\\". My father served nearly 23 years in the military, he had a strong sense of self-discipline and the ability to execute a defined task. After getting out of the Air Force, he got back into long-distance running, now running Ultra-Marathons, 100 mile races, and more. I obviously didn't have this same sense of discipline, and that wouldn't work for me.\n\nDiscipline is important still, but solely relying on self-discipline wasn't going to get me anywhere, I needed more than that. I'm a big fan of the Pomodoro technique. With this technique, you create a small cycle of work and rest, with a big rest after four iterations of the cycle. I personally do 25 minutes of work, 5 minutes of rest. After 4 iterations of this (2 hours), I take a 30 minute break where I typically do yoga, eat a meal, or even just watch YouTube. Knowing that I have a break after only 25 minutes helps to keep me working on my task. Additionally, the app I use for tracking this ticks like a clock, which serves to remind me to stay on task.\n\nAnother tip my dad gave, which I now live by, is to make lists. Relying on your memory to get stuff done might work, but it's also draining. Every time you complete a task, you have to spend the mental effort figuring out the tasks you have for yourself, and prioritise those tasks. This wears you out, and contributes to a concept called decision fatigue. Making decisions is tiring, mentally. If you make a todo list at the start of your day and give each item a priority, you can help eliminate this. You decide what's important once, and then you can just reference that throughout the day. You don't need to complete everything on your list, just something. Plus, it feels really satisfying to check items off your list. One of the things I found most useful is to reward yourself. Everyone's rewards will be different, but positive reinforcement is the best way to encourage a habit. One thing I find really important is to predetermine your rewards. Going back the todo list's concept of decision fatigue, trying to decide what to reward yourself with can make the act of rewarding yourself feel like a chore sometimes. When you take the time at the start of your day to consider your potential rewards, and maybe even assign them to each task, you eliminate the need to make a choice, you can just accept the reward and use your breaks as you see fit. \n\n---\n\nI still don't complete every task I do. But now, I get a lot more done than I used to. I'm able to motivate myself to keep working on something, even when it no longer has my interest, as long as I have a clearly defined goal to push me to work on it. I've also found a healthier work-life balance, and don't spend all my time either working, doing schoolwork, or trying to finish my portfolio website. I find time to relax, play videogames, and spend time with friends. Finding a system that works for me has helped me to become a happier, kinder, and more successful person, and it can do the same for you. It's not as tough as you might think, and you'll see the rewards pretty quickly.

Many people struggle with seeing a task through to completion. It can be really tough to find productivity methods that work for you, so the key takeaway is to try a few different ones out.

On Completion

Coming to the end of your University experience is an exciting but scary time. The joy and sensation of completing your graduation is rewarding, but then comes the time to go into the big bad world.\n\nThe obvious first thought is applying anywhere and everywhere. Whilst this is true, the importance of reading the advertised job description is just as important, as this allows you to see what the company requires and what the job entails. This ranges for various language skills along with personal experience. Rather than going through recruitment agencies, researching and applying with the company direct makes you stand out more compared to other candidates.\n\nA common sight that you will see is that a large number of companies will require previous commercial experience, meaning on the graduate scale, we are overlooked by many. To counter this, keyword search is useful with the terms Graduate or Junior to ensure that the jobs which appear match these criteria or are close to that term. But don't let this stop you from applying to the companies that do require experience, as you'll never get the opportunity if you don't apply.\n\nIn my recent job search, I started applying whilst I had another 3-4 month left at University. This meant that in that time I had a few interviews and despite the rejection of the offer, I still gained the experience of what to expect in an interview. I had around 5 interviews, not being successful in 4 of them until I was offered a position from my final interview.\n\n# How To Prep For Interview\nWhen applying to companies, it's always important to attach a portfolio of your work, along with your CV. This allows the company to inspect your knowledge based on your code: having live examples of projects is also greatly beneficial. At the end of my last interview, the developer gave me a quiz to test my knowledge and then asked for my GitHub link so that she could \"be nosy and look at my work\" which showed some level of interest in me as a developer.\n\n# The Interview\nWith the recent pandemic, half of my interviews were online; but this doesn't mean you can stay casual! Even at the comfort of your own home, dress to impress, well at least upper body, as I wore a smart jacket and shirt then had shorts on. Before joining the meeting, triple-check that everything is working, i.e. webcam and microphone - don't make a bad impression by not checking beforehand.\n\nFor my interviews which were face to face, I dressed to impress (this time including my lower body) and ensured I was prepared, arriving early to my meeting. There's nothing saying you aren't allowed to take notes or even help yourself to stand out. Have information about yourself ready to discuss, a copy of your own CV as well as information about the company you are applying for, or at least conduct research into the company before going and preparing questions to ask your interviewer.\n\n**Remember:** You want to be leaving that interview confident and satisfied with your performance, even if you don't get the job in the end because someone was more qualified. Just be satisfied that you gave it your all and that you can be proud of that stage.\n\nTo summarize:\n- Prepare and research the company before attending the interview\n- Have questions ready to ask, quality is better than quantity\n- Dress smart and look the part\n- Be confident and ensure you sell yourself\n- Don't be hard on yourself if you feel like you aren't getting anywhere, we all feel the same\n\n I hope this helps you and good luck with a career in development!

Coming to the end of your University experience is an exciting but scary time. The joy and sensation of completing your graduation is rewarding, but then comes the time to go into the big bad world.

How I Got A Job After University During The Pandemic

If you're anything like me then I feel sorry for your plants, you buy them with great intention of keeping good care of them, then suddenly a week has gone by and you have forgotten to water them... Rather than taking the sensible option and just, you know, watering them, I decided that this would be a fun project for my Raspberry Pi that has recently been collecting dust. To spice things up a little bit I decided to challenge myself to write all of the code required to build this in [Dictu.](https://dictu-lang.com/) For those not in the know, Dictu is a programming language created by yours truly. Before I started with the project, I had a few requirements that I wanted to meet for this to be considered a successful project by myself.\n\n1. For it to actually work correctly...\n2. For all (if not most) of the code to be written in Dictu\n3. For it to only water when soil levels reach a certain \"dryness\" rather than on a schedule\n4. For it to monitor water levels and notify me when they are low\n5. Everything to be encased in a semi-presentable format\n\n# GPIO\nBefore setting off and ordering a load of parts for the Raspberry Pi, I wanted to make sure that I could actually work with the RPi GPIO pins via Dictu, which involved creating a GPIO library of sorts. This (luckily) turned out to be a lot simpler than I had first thought, it boils down to reading and writing to files depending on the desired action. With help from already written things, such as [this node library](https://github.com/JamesBarwell/rpi-gpio.js) and [this shell snippet](https://elinux.org/RPi_GPIO_Code_Samples#Shell), I managed to create a very simple library that deals with exactly what I want. Before I get into the Dictu library, I thought it's best to explain a little about how the GPIO pins are controlled via the filesystem - if you're not interested in this part, feel free to skip to the next section.\n\nAll GPIO files are located within the `/sys/class/gpio` directory, in here is where we can `export` and `unexport` pins. `export`-ing a pin is essentially \"activating\" a pin on the RPi board, and this needs to be done before we can do anything with the pin. You export a pin by writing a pin number to the `export` file (note pin numbers here are BCM numbers and **not** physical pin numbers). Once the pin has been exported it will create a new directory with the name `gpio<num>` where `<num>` is the pin number which has just been exported along with other files within the new directory. For example, if we export pin 17 then it will create a new directory `gpio17` with the following structure\n\n```\ngpio17 \n-- active_low\n+-- device -> ../../../gpiochip0\n+-- direction\n+-- edge\n+-- power\n| +-- autosuspend_delay_ms\n| +-- control\n| +-- runtime_active_time\n| +-- runtime_status\n| \\-- runtime_suspended_time\n+-- subsystem -> ../../../../../../../class/gpio\n+-- uevent\n\\-- value\n``` \n\nAfter exporting a pin we next need to set its `direction`, since pins can be used for both input and output we need to tell the pin which it is we want to do, so for example, if we want to read data from a sensor we need to set the direction of the pin to `in` however, if we want the pin to act as a power output, e.g to power an LED, we need to set the direction to `out`. This is simply done by writing either `in` or `out` to the `direction` file. The next file we need to use is `value`. Similar to direction, how we interact with it is based upon whether our pin has been setup for reading or writing (in or out). If our pin is in an input state then we will read the `value` file, and based on the input from the external circuit, it will either read 1 (high) or 0 (low). Similarly, if we are in an output state, we use 1 (high) and 0 (low) however, we write these values to the `value` file instead of reading. There are obviously other files within the `gpio17` directory, but they were unnecessary for this project. Finally, once you are done with the pin we need to `unexport` it to clean the pin up. Just like exporting you write the pin number to the `unexport` file.\n\n ## Dictu GPIO\n```js\nimport Path;\n\nclass GPIO {\n \tvar PATH = \"/sys/class/gpio\";\n \tvar ACTIVE_PINS = {};\n\n \t/**\n \t * pin: BCM pin number\n \t * direction: in or out\n \t */\n \tstatic setup(pin, direction) {\n \t\tif (pin < 0 or pin > 40) {\n \t\t\treturn Error(\"Invalid pin number, must be between 0-40\");\n \t\t}\n\n \t\tpin = pin.toString();\n\n \t\tif (![\"in\", \"out\"].contains(direction)) {\n \t\t\treturn Error(\"Pin direction must be in or out\");\n \t\t}\n\n \t\tvar pinObject = Pin(pin, direction);\n \t\tGPIO.ACTIVE_PINS[pin] = pinObject;\n\n \t\treturn Success(pinObject);\n \t}\n\n \tcleanAll() {\n \t\tGPIO.ACTIVE_PINS.keys().forEach(def (key) => {\n \t\t\tconst pin = GPIO.ACTIVE_PINS[key];\n \t\t\tpin.cleanup();\n \t\t});\n \t}\n}\n\nclass Pin {\n \tvar PATH = \"/sys/class/gpio\";\n\n \tinit(private pin, private direction) {\n \t\tthis.unExport();\n \t\tthis.export();\n\n \t\twhile (!System.access(\"{}/gpio{}/value\".format(Pin.PATH, this.pin), System.R_OK | System.W_OK).success()) {\n \t\t\tSystem.sleep(0.01);\n \t\t}\n\n \t\tthis.setDirection();\n \t}\n\n \tread() {\n \t\tvar content = \"\";\n\n \t\twith(\"{}/gpio{}/value\".format(Pin.PATH, this.pin), \"r\") {\n \t\t\tcontent = file.read().strip();\n \t\t}\n\n \t\treturn content;\n \t}\n\n \twrite(value) {\n \t\tconst allowedValues = {\n \t\t\ttrue: \"1\",\n \t\t\tfalse: \"0\"\n \t\t};\n\n \t\tconst writeValue = allowedValues.get(value, nil);\n\n \t\tif (writeValue == nil) {\n\t\t\treturn Error(\"Invalid write value\");\n \t\t}\n\n \t\twith(\"{}/gpio{}/value\".format(Pin.PATH, this.pin), \"w\") {\n \t\t\tfile.write(writeValue);\n \t\t}\n\n \t\treturn Success(nil);\n \t}\n\n \tcleanup() {\n \t\tthis.unExport();\n \t}\n\n \tprivate export() {\n \t\tif (!Path.exists(\"{}/gpio{}\".format(Pin.PATH, this.pin))) {\n \t\t\twith(\"{}/export\".format(Pin.PATH), \"w\") {\n \t\t\t\tfile.write(this.pin);\n \t\t\t}\n \t\t}\n \t}\n\n \tprivate unExport() {\n \t\tif (Path.exists(\"{}/gpio{}\".format(Pin.PATH, this.pin))) {\n \t\t\twith(\"{}/unexport\".format(Pin.PATH), \"w\") {\n\t\t\t\tfile.write(this.pin);\n \t\t\t}\n \t\t}\n \t}\n\n \tprivate setDirection() {\n \t\twith(\"{}/gpio{}/direction\".format(Pin.PATH, this.pin), \"w\") {\n \t\t\tfile.write(this.direction);\n \t\t}\n \t}\n } \n```\n\nThis is essentially the entire GPIO library used, written in Dictu. There could definitely be improvements made to it, however, I kept it incredibly simple for this project. Once I had this written I tested it using a breadboard along with an LDR (Light Dependent Resistor) I had lying around, and it worked great!\n\n# Parts\nOnce I had a functioning GPIO library I was happy to get my wallet out and order the parts required to create this. I used [The Pi Hut](https://thepihut.com/) to order my parts and they were great (no this isn't a sponsored post).\n\n## Parts List\n - [Immersible Pump & WaterTube](https://thepihut.com/products/immersible-pump-watertube?variant=27740797585)\n - [Soil Moisture Sensor](https://thepihut.com/products/soil-moisture-sensor?variant=20063171805246)\n - [Relay](https://thepihut.com/products/gravity-relay-module-v3-1?variant=27740618897) - [Ultrasonic Distance Sensor](https://thepihut.com/products/ultrasonic-distance-sensor-hcsr04?variant=1054704288)\n - [Ultimate Resistor Kit](https://thepihut.com/products/ultimate-resistor-kit?variant=36476117073)\n - [12V Power Supply](https://thepihut.com/products/arduino-universal-power-supply-12v-2a-high-voltage?variant=20063055773758)\n - [Power Switch](https://thepihut.com/products/in-line-power-switch-for-2-1mm-barrel-jack?variant=27739226065)\n\n **Total: &pound;43.49**\n\n Most of the parts in the list are fairly self-explanatory however I will explain about a couple of the parts in a little more depth. \n\n## Ultrasonic Sensor\nThe ultrasonic sensor is effectively two speakers and a receiver, it pumps out a sound wave which bounces off an object and is caught by the receiver. This is useful to us because we can time how long it takes for the sound wave to bounce and come back and work out how far its travelled - this means we can work out whether or not we need to fill the \"tank\" up with water.\n\n### More Detail\nSound waves travel at 343m/s at sea level through air and if you remember back to your days of Physics lessons you may remember that `speed = distance / time`. We know the speed the sound wave is travelling, we are monitoring how long it takes and we are attempting to find the distance the sound wave has travelled, so with a bit of rearranging we end up with `distance = speed * time`. We however are not done there, this would give us the **total** distance travelled by the sound wave, which is 2 times to big (since it's hitting the water container and bouncing back), so we end up with `distance = speed * time / 2`.\n\n## Relay\nA relay is a fancy electronically operated switch. We need a relay here since our pump is working on 12V and the RPi works at 3.3V (also 5V pins), this means we will need a completely separate circuit setup, however it still needs to be controllable by the pi. ![What is a Relay? - Circuit Basics](https://api.codesupport.dev/file/v1/images/articles/rsRH6rjwrUKwq8ZNtBQl.png)\n\nA relay works by using an electromagnet to either open or close a circuit depending upon whether or not a voltage is being supplied to the signal pin and how the circuit is setup on the opposite side of the relay. If the circuit is setup via \"Common\" and \"Normally Closed\" this means the circuit is closed (not active) when there is no current being passed to the signal pin, however if it was setup so that it uses \"Common\" and \"Normally Open\" the circuit would default to open (active) when there is no current being passed to the signal pin. In our case we only ever want the pump to be active when we turn on the GPIO pin (signal pin) so in this scenario the \"Normally Closed\" option is chosen.\n\n ## Case\nOne of my requirements is that it is in a presentable format, in theory I will be using this system on 3 bonsai trees that I have growing and ideally I don't want an absolute mess around the trees, since you know, you don't want to have to gouge your eyes out. To do this I created my own case with a 3D printer. It is essentially in 3 different parts, the water container at the bottom holding the submersible pump and obviously water, the middle section which holds the Raspberry Pi and related electronics and then finally the lid. To design the different sections I used [AutoCAD](https://www.autodesk.co.uk/products/autocad/overview), which luckily for me, provides free access to students (again not a plug), otherwise you're looking at thousands for a license - which isn't really what I was looking to pay for a hobby experiment. Anyways... after a lot of pretending to measure things, and some trial and error, I ended up with these 3 designs.\n\n![img](https://api.codesupport.dev/file/v1/images/articles/rFA3iKFu3onzbD1BT0C1.jpg)\n![img](https://api.codesupport.dev/file/v1/images/articles/LgQ3IEWUYGTFeVwCL3ua.jpg)\n![img](https://api.codesupport.dev/file/v1/images/articles/SqkRwIRAahGpCm95xxUV.jpg)\n\nAnd then it was finally time to print!\n\n# Printing\nA couple of failed attempts and a few days, I eventually reached a stage where I could begin placing components within the printed design!\n\n![img](https://api.codesupport.dev/file/v1/images/articles/i5Cn4DdH7yVnH3Gc8ml8.jpg)\n \n**Note: I did cheat here and use a breadboard and jumper cables, sorry.**\n\n# Writing The Project Code\nI was now at a stage where I had a proof-of-concept GPIO library written, and a container for the electronics; it was finally time to write the actual project code and finish this!\n\n## Getting Soil Moisture Level\nThe first thing tackled was hooking up the soil moisture level sensor. Since the Raspberry Pi deals with digital inputs, this sensor will give off either a high reading or a low reading depending upon whether or not the soil is dry (configurable via a potentiometer).\n\n```js\n/** \n * Get the soil moisture level.\n * - 1 means the level is dry\n * - 0 means the level is wet\n */\ndef getSoilLevel() {\n \tconst pin = gpio.setup(17, \"in\").unwrap();\n \tconst level = pin.read();\n \tpin.cleanup();\n \treturn level;\n }\n\n```\n\nThe above code is hopefully fairly self-explanatory, we essentially get input from the sensor which is either \"dry\" or \"wet\".\n\n## Measuring The Water Level\nThe main container sits atop of the water container, this allows us to measure the distance of a sound wave from the main section to the bottom of the water container telling us how much water is left in the container. The slight caveat here is that sound actually travels much faster in water than it does in air, which means it slightly throws off the distance measurement since we are using the constant at which it travels in air (343m/s). This in theory however should not make a difference, because it will give us a lower reading rather than higher, so we can just cater for this.\n\n```js\n/** \n * Get the amount of water in the container.\n * Printed container is ~3.7cm deep, this means if we hit 3 centimeters\n * it needs refilling.\n */\ndef getWaterLevel() {\n \tconst trigPin = gpio.setup(23, \"out\").unwrap();\n \tconst echoPin = gpio.setup(24, \"in\").unwrap();\n\n \ttrigPin.write(false).unwrap();\n\n \t// Settle sensor after reset\n \tSystem.sleep(2);\n \ttrigPin.write(true);\n \tSystem.sleep(0.00001);\n \ttrigPin.write(false);\n\n \tvar pulseStart = System.time();\n\n \twhile (echoPin.read() == \"0\" and System.time() - pulseStart < 5) {}\n\n \tvar start = System.time();\n\n \tpulseStart = System.time();\n\n \twhile (echoPin.read() == \"1\" and System.time() - pulseStart < 5) {}\n\n \tvar end = System.time();\n \tconst pulseDuration = end - start;\n\n \t/**\n \t * Speed of sound at sea level is 343m/s\n \t * Formula is speed = distance / time, however our formula is\n \t * speed = distance / (time / 2), since we only care about the speed\n \t * from the distance of the sensor to the object (not back again).\n \t *\n \t * 34300 = distance / (time / 2)\n \t * 17150 = distance / time\n \t * distance = 17150 * time\n \t *\n \t * Note: Speed of sound in water is faster, but that doesn't matter\n \t * much in this case since it'll reduce the \"distance\", and we're\n \t * checking for an empty container.\n \t */\n\n \tconst distance = pulseDuration * 17150;\n\n \ttrigPin.cleanup(); \techoPin.cleanup();\n\n \treturn distance;\n}\n``` \n\n## Activating The Pump\nOnce we receive the signal that the soil is dry and the container is not empty, we then want to turn on the pump.\n\n```js\n/** \n * Activate the water pump\n */ def runPump() {\n \tconst pin = gpio.setup(18, \"out\").unwrap();\n\n \tprint(\"Running Pump!!!\");\n \t// Turn pump on\n \tpin.write(true).unwrap();\n\n \tconst startTime = System.time();\n \t// Wait until the sensor measures wet soil OR 5 seconds has passed\n \twhile (getSoilLevel() == \"1\" and System.time() - startTime < 5) {\n \t\tSystem.sleep(0.1);\n \t}\n \t// Turn pump off\n \tpin.write(false).unwrap();\n \tpin.cleanup(); } \n``` \nThe script will run until the soil is wet OR until 5 seconds has passed. The 5 seconds is more of a failsafe incase anything goes wrong with the sensor and the pump is never switched off. \n\n## Running\n```js\n/**\n * Entrypoint\n */\ndef monitor() {\n \tconst waterLevel = getWaterLevel();\n \tprint(\"Water level {}\".format(waterLevel));\n \t// Water is empty\n \tif (waterLevel >= 3.7) {\n \t\tprint(\"Water empty!!\");\n \t\treturn;\n \t}\n \t// Water is getting low\n \tif (waterLevel >= 3) {\n \t\tsendNotification();\n \t}\n \tconst soilLevel = getSoilLevel();\n \tprint(\"Soil level {}\".format(soilLevel));\n \tif (soilLevel == \"1\") {\n \t\trunPump();\n \t} }\n``` \n\nPutting this all together we have our entry point, our \"main\" function if you will. The water container printed currently can has a depth of around 3.7cm, so we send a notification when we have around 3cm of distance because at this point the water level is getting low. The notification sent is an SMS message via [Twilio SMS API.](https://www.twilio.com/docs/sms/api) \n\n# Round Up\nThis was a really interesting project to make, I'm sure there are things that can be improved, or additional things that could be added however I'm currently at a stage where I'm happy with the project. Looking back I managed to hit those 5 requirements I'd set out to meet which, honestly, is not what I was expecting.\n\n ![img](https://api.codesupport.dev/file/v1/images/articles/cCYYNIbdh1BYkNvfG1vq.jpg)

Creating an automatic watering system with a Raspberry Pi and the twist of using Dictu.

Automatic Watering System With A Raspberry Pi

A common problem which I face when using the Firebase Emulator with the Node.js debugger is that my debugger stops running when I am done, but the Firestore Emulator does not stop running. In this article I will explain how you can get around this issue.\n\nOriginally, to get around this I would go into my `firebase.json` configuration file like it suggests and would temporarily change the port. However, this method is not very efficient as you could run into the same issue over and over again. Luckily, there is an easy fix to this problem.\n\nUsing the `lsof` command you can list all open files and processes on a Unix-based system. Upon running this command you will find that you are presented with a long list, thankfully we can filter this down by just listing open files and processes on a specific port. In our case, the Firestore Emulators run on port `2255`, so we can run `lsof -i :2255` which should return a similar response to this:\n```\nCOMMAND PID USER\njava 7254 my.user\n```\n\nThis shows us that `java` is running for `my.user` on process ID `7254` (your PID and USER values will be different). We can then take this information and run `kill 7254` (replacing `7254` with your process ID) to kill the Firestore Emulators. This means that you will then be able to start the Firestore Emulators on the same port as before.\n\n# TLDR\n1. Run `lsof -i :2255`\n2. Find the PID of java\n3. Run `kill <the PID of java>`\n\nI hope you find this trick useful, I know that it's certainly helped me out multiple times!

A common problem which I face when using the Firebase Emulator with the Node.js debugger is that my debugger stops running when I am done, but the Firestore Emulator does not stop running.

How To Kill The Firestore Emulator

While there are lot of hidden gotchas in C++, there are also many useful features that have evolved from all sorts of poorly defined behavior and hacked-on additions that have become useful tools in my box with doing day-to-day work.  This post aims to explore a few of the ones I could remember off of the top of my head from looking at my game engine project, [Ona](https://github.com/Kayomn/Ona), and explore how and why they can be helpful in reducing code duplication, avoiding slowdowns, and producing code that needs to do less at run-time.  # Beyond Pimpl  In my experience, I have never found the very rigid examples of the "pimpl" design pattern useful. My issues with pimpl sit with how it adds a lot of unnecessary run-time overhead to excuse poor support for hiding implementation details. That withstanding, it is possible to get a lot more mileage out of this design pattern by ignoring the most common examples of its application.  ```cpp class External { 	class Internal;  	Internal * internal;  	public: 	External();  	~External(); }; ```  The most common application of Pimp is to wrap a dynamic allocation - which itself may sometimes be wrapped in either a `std::unique_ptr` or `std::shared_ptr` rather than a regular C pointer. Evidently, this disregards the hard run-time needs of the application for the sake of hiding some data.  Usage of a Pimpl-like pattern became very necessary for a recent project I was working on, which was implementing a document object model-like structure for browsing configuration data.  ```cpp class ConfigEnvironment final : public Object { 	struct Value;  	HashTable<String, Value> globals;  	public: 	// ... }; ```  `Value` contains a lot of data and a lot of member functions. Were these exposed in the header, it would not just make it harder for readers to parse, but also the compiler itself.  However, by happenstance, I discovered that my implementation of `HashMap` does not need to care about the size or layout of `Value` at this stage of compilation, so it is perfectly happy to accept an incomplete type as one of its type arguments.  ```cpp struct ConfigEnvironment::Value { 	enum class Type { 		Object, 		Boolean, 		Integer, 		Floating, 		String, 		Vector2, 		Vector3, 		Vector4, 		Array, 	};  	enum { UserdataSize = (64 - sizeof(Type)), };  	Type type;  	uint8_t userdata[UserdataSize]; }; ```  Within the implementation file, the actual layout of the struct is defined for the compiler to see when compiling this file but never anywhere else.  No performance is lost here by using Pimpl over defining `Value` in the header, and a lot of implementation details have been hidden from public view, saving potential time in the future when parsing the header.  The example of this version of Pimpl in action can be found [here](https://github.com/Kayomn/Ona/blob/2c6e39326a1f38b1472476b8dc1bc6a351fb1311/engine.hpp#L174) and [here](https://github.com/Kayomn/Ona/blob/2c6e39326a1f38b1472476b8dc1bc6a351fb1311/engine/script.cpp#L4).  # Stateful Lambdas  Lambdas are a very useful feature that was introduced in the C++11 standard revision. While the most popular use of lambdas is as arguments to other functions, they also have a lot of use as local functions.  ```cpp void doThing() { 	char const * message = "Hello, world\n";  	auto doThingALot = [message](int iterations) { 		for (uint64_t j = 0; j < iterations; i += 1) { 			printf("%s", message); 		} 	};  	for (uint64_t i = 0; i < 100; i += i) { 		doThingALot(i); 	} } ```  Similar to [C# local functions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/local-functions), these functors are able to capture the local scope and perform repetitive tasks, reducing repeated code while still retaining all the compiler optimizations of regular C++ functions.  In fact, a lot of useful techniques can arise from lambdas that capture the local scope, with one of which being *stateful lambdas*. Stateful lambdas are a practice I employed recently in the development of a lexer I wrote.  ```cpp auto eatToken = [&, i = (size_t)0]() mutable -> Token { 	// ... } ```  The declaration of `i = (size_t)0` is creating a scoped variable of type `size_t` within the `eatToken` functor. By default, `i` is not mutable, erasing any potential use for this feature beyond some extra automatic scoping. Luckily, C++ is a language that allows any data to have its `const`-ness broken at any time with the use of `mutable`.  ```cpp auto eatToken = [&, i = (size_t)0]() mutable -> Token { 	i += 1;  	// ...  	return Token{/** ... */} } ```  Now, the `eatToken` functor is free to change the value of `i` as much as it likes whenever it is called. Each new invocation will retain the state of `i` from the last, without needing to rely on hacky solutions like global data.  In the lexer, this was leveraged to create an `eatToken` function that would lazily tokenize a string of data and spit out each new token that was found as a `Token` type. Once the end of the string was reached, only end-of-file tokens were produced to mark the terminating state for the parser loop.  For readers that are not familiar with the problems surrounding lexing text, this meant that it was no longer necessary to keep a full in-memory representation of all lexed tokens.  ```csharp Token EatToken(string text) { 	var i = 0;  	// ...  	while (i < text.Length) 	{ 		i += 1;  		yield return new Token(/** ... */); 	} } ```  > *Example of `eatToken` in C#*  ```js function* eatToken(text) { 	let i = 0;  	// ...  	while (i < text.length) { 		i += 1;  		yield { 			tokenType: TokenType.eof, 			tokenText: "", 		}; 	} } ```  > *Example of `eatToken` in ECMAScript*  ```py def eat_token(text: str) -> Generator[dict, None, None]: 	i = 0  	# ...  	while (i < len(text)): 		i += 1  		yield { 			"token_type": TokenType.EOF, 			"token_text": "", 		} ```  > *Example of `eatToken` in Python*  Languages like C#, ECMAScript, and Python feature very similar concepts with nicer-looking APIs, but falter in implementation as they all rely on dynamic allocations to work, while mutable functors do not have this problem.  The implementation of `eatToken`, as well as the full lexer and parser source code, can be found [here](https://github.com/Kayomn/Ona/blob/2c6e39326a1f38b1472476b8dc1bc6a351fb1311/engine/script.cpp#L157).  ## Small Buffer Optimization  New C++ users who are familiar with programming may be inclined to always reach for `new` whenever they need a buffer of memory that cannot be reasoned about at compile time. While C++ may resemble more managed languages like C# and Java, its dynamic memory model does anything but - because there is not one.  C++ is more than happy to grab memory from the operating system directly by the page and then split it into smaller chunks as needed, albeit at a relatively high cost. Languages like C#, Go, and Java all use managed pools of commonly used memory chunks pre-allocated by the run-time to speed up their allocation abilities.  Short of implementing a custom memory pool and allocation library, there is not an easy way of creating relatively cheap dynamic memory allocations right now. Despite that, C++ can do something that many managed languages cannot: allocate on the stack.  ```cpp struct String { 	private: 	enum { StaticBufferSize = 24, };  	uint32_t size;  	uint32_t length;  	union { 		uint8_t * dynamic;  		uint8_t static_[StaticBufferSize]; 	} buffer;  	public: 	// ... }; ```  Many examples of C++ software that I have written in the past feature standard library-adjacent code that exists with the sole purpose of facilitating optimizations for small amounts of data. These small buffers are used up until the limits are exceeded by the spatial needs of the data itself.  ```cpp template<typename Type, size_t InlineMax> class InlineArray final : public Object, public Array<Type> { 	size_t length;  	union { 		Type * dynamic;  		Type static_[InlineMax]; 	} buffer;  	public: 	// ... } ```  Further control over what these "limits" are can be given to the user of the library directly via template parameters, which accept a value specifying the maximum size for the small buffer.  The implementation of the above small-buffer optimized `String` struct can be found [here](https://github.com/Kayomn/Ona/blob/2c6e39326a1f38b1472476b8dc1bc6a351fb1311/common.hpp#L219).  # Fixed Array Arguments  Sometimes you just want to be able to accept an array as an argument. I had this crop up when implementing a static array wrapper called `FixedArray`.  A hypothetical C++ programmer's first thought my be to reach for `std::initializer_list` or use a templated function, but if the maximum size of the array is known, it turns out doing it is fairly trivial and can be template-free.  ```cpp template<typename Type, size_t Len> class FixedArray final : public Object, public Array<Type> { 	Type buffer[Len];  	public: 	// ...  	FixedArray(Type (&values)[Len]) { 		for (size_t i = 0; i < Len; i += 1) { 			this->buffer[i] = values[i]; 		} 	}  	FixedArray(Type (&&values)[Len]) { 		for (size_t i = 0; i < Len; i += 1) { 			this->buffer[i] = std::move(values[i]); 		} 	} } ```  In the above example, two overloads of the constructor are defined, with one being optimized for perfect forwarding and the other being designed for indirect bit copying.  ```cpp static FixedArray<Vector4, 6> const quadVertices = {{ 	Vector4{1.f, 1.f, 1.f, 1.f}, 	Vector4{1.f, 0.f, 1.f, 0.f}, 	Vector4{0.f, 1.f, 0.f, 1.f}, 	Vector4{1.f, 0.f, 1.f, 0.f}, 	Vector4{0.f, 0.f, 0.f, 0.f}, 	Vector4{0.f, 1.f, 0.f, 1.f} }}; ```  This allows code that wants to act like a regular array, act like an array with minimal to no run-time overhead associated.  The implementation and usage of `FixedArray` can be found [here](https://github.com/Kayomn/Ona/blob/2c6e39326a1f38b1472476b8dc1bc6a351fb1311/common.hpp#L771) and [here](https://github.com/Kayomn/Ona/blob/2c6e39326a1f38b1472476b8dc1bc6a351fb1311/engine/opengl.cpp#L9) respectively.  ## Conclusion  There is a lot that can be done with C++. Some it is good, some of it is terrible, some of it is even worse than terrible. Despite this, I still find it to be the most versatile tool that exists for systems-level programming, and a lot of these features go a long way to demonstrate why that is.

While there's a lot of hidden gotchas in C++, there's also many useful features that have evolved from all sorts of poorly defined behavior that have become useful tools in my box with doing day-to-day work.

Some Useful C++ Tricks

Many languages will include the concept of **scope** to one degree or another. **Scope** determines where your variables are "visible" and where they are not. Imagine a box, and all sides of this box are a one-way mirror, where you can look out from inside the box, but no one can look into the box from the outside. Variables that are created inside the box are not visible to anyone outside of the box. Contrastingly, any variable created outside can be seen from those that are inside the box just fine.  	let x = 10; 	{ 		let y = 5; 		print(x); 		print(y); 	} 	print(y);  In many different languages of programming (but not all), scope can be structured using curly braces ({ }). In the previous example, we declare a variable 'x' and initialize (assign) it with a value of 10. We then define the beginning of a new **scope** by way of the opening curly bracket ({). This new scope extends from the opening bracket until it's **matching closing one** (more explanation in a minute). This scope can be referred to as the "inner scope", which is a relational term, where as outside the brackets would be the "outer scope", again used relationally.  Remembering the box with the one-way mirror metaphor, the variables defined in the outer scope are clearly visible to the inner scope. However, the variables within the inner scope are completely hidden from the outer scope, just as items inside the box were not visible to those outside the box. This means that we can print the value of our variable 'x' from the inner scope just fine, as well as the variable 'y' which was declared within the inner scope. Our scope then closes with the closing curly bracket (}), and thus we re-enter the outer scope, where we then try to print() our 'y' variable again. Being that we are in the outer scope now, the 'y' variable is not visible to us anymore, because it was created in the inner scope, so this statement will actually likely generate an error in our program (depending on the programming language we are using).  Scope is something that can be a little tricky to follow the first time it's described, and is a very common stumbling point for many beginners. As mentioned earlier, different languages also handle scope in varying ways and to varying degrees. Some langauges will only have two scopes, the global scope (outer), and the not-global, or local scope (inner). Other languages will allow you to define many different scope levels, such as the following example:  	let x = 10; 	{ 		let y = 5; 		{ 			let z = 15; 			print(x); 			print(y); 			print(z); 		} 		print(x); 		print(y); 	} 	print(x);  Here we can see there are 3 scope levels, with 'x' being declared on the outer-most scope, 'y' on the next inner scope, and 'z' on the inner-most scope. As before, each scope can access it's own variables as well as the variables declared in scopes outside of it. You can see by the print() statements which variables we have access to at each scope level. You also may remember that it was previously mentioned that scope boundaries are defined as starting at the opening curly bracket and running until it's **matching closing one**. This means that when we opened our first scope, and then opened another one inside that, we would have to first close our inner-most scope before we can close the one outside of it.  Proper indentation becomes very critical in this aspect of programming to help you clearly see the different levels of your code. Many languages completely ignore white space (spaces, tabs, returns, etc.), and you could write all this code on a single line if you wanted.  	let x = 10;{let y = 5;{let z = 15;print(x);print(y);print(z);}print(x);print(y);}print(x);  The code will still execute as expected, it just makes it very hard for us humans to read it and understand what is going on. For this reason it can also make it very hard to see **bugs**, which is the term used in programming to denote a piece of code that is doing something incorrectly, or not as intended. Say perhaps you put the closing curly bracket in the wrong spot.  	let x = 10; 	{ 		let y = 5; 	} 	print(y); 	print(x);  As we have learned earlier, this will generate an error in many languages, due to accessing a variable that is in the wrong scope (the 'y' variable). However it does become a little harder to identify when we don't have good indentation to help us see it, such as with the following alternate representation of the same code:  	let x = 10;{let y = 5;}print(y);print(x);  It's always a good idea to practice keeping your code looking clean and organized so that it's easier to read and identify issues.

Brief overview and definition of Variable Scope

Introduction to Programming: Variable Scope

No matter which language you use, you will most likely be dealing with different types of data. What is meant by this? Well, in the previous example we used a Number, a 5 to be exact, which is one type of data. In actuality, there are many types of data that we may need to use in our program depending on what it does, and most languages will have a concept of the three basic types, which can further be broken down into more specific types in some languages.  # Numbers  As already discussed, a number is any value that represents a numeric value, such as the 5 that we used in our previous examples, or even decimal values, like 3.14. Depending on the language that you use, numbers might be further broken down into even more specific types, such as Integer and Float. Again, if you remember your definitions from mathematics, an Integer is a "Whole Number" that can be either negative or positive (or 0!). A Float would be in reference to a floating-point value, which is one with a decimal value, such as 3.14 or 12526.18369.  Languages with these types will likely have size limits on how big the number can be, due to memory storage concerns. For instance, an Integer might only be able to be a number between about -2 billion and +2 billion. If you needed to store larger numbers, you would need to use a different type denoted by a different name, which can depend on the language used. These concepts can seem confusing at first, but it basically just comes down to how we are able to store data in memory. You can read more about this in *<link:Data Types in Memory>*.  # Boolean  A boolean is a simple type of data that you might recall from algebra and it has only two values, true or false. In some languages a boolean may actually just be a tiny number type that is either 1 (for true) or 0 (for false), but others abstract this into **literal** values "true" and "false" to make code nicer to read. Booleans are used frequently for condition logic, which is basically like "If this is true, then do this", which will be discussed more later. An example of storing a boolean value might look something like this (note we're using a boolean **literal** here):  	let hasChocolate = true;  # Strings  Another type of data could be a String, which if you haven't taken discrete mathematics yet, is just a sequence of characters strung together, such as "Hello world!", which has twelve characters (yes we include the space and exclamation point!).  In our previous example on output, we had printed out the number 5 to the console by first storing it in a variable and then using our special print() statement (again, we'll discuss functions more later, so don't worry if that seems confusing). We could also print other things out, such as the Strings we mentioned earlier:  	let greeting = "Hello World!"; 	print(greeting);  This will print out the words 'Hello World!' to the console, however it will not print out the double quotation marks. The double quotes are simply how we have to write String **literals** in code (Remember, a **literal** is a value that is represented by an actual value, so like 5 is a numeric literal value and "hello" is a string literal). If we wanted to store the String "dog" in a variable and we were to just write:  	let animal = dog;  The compiler would get confused thinking we meant we wanted to copy the value inside a variable called 'dog' to the variable 'animal'. The double quotes allow us to tell the compiler we are assigning a String literal, not grabbing the value from inside another variable called 'dog'. Thus the correct statement to do what we wanted is:  	let animal = "dog";  # Arrays  I know, I said three basic types, but we're throwing in a fourth that is a little different from the others. An array is basically just a sequence of values of a specific type. What does that mean? Well if we were to think of books on a book shelf, each book could be like one of our values. So one book represents a 5, maybe another book represents a 21, etc. Instead of our variable referencing just one of these values (books), we instead have a variable that is referencing the entire bookshelf.  ![Books on a bookshelf](https://api.codesupport.dev/file/v1/images/6y9h8cVBh0U3fFjSZX3t.svg)  So in essence, our variable has many values inside of it, not just one. They aren't just inside randomly though, they are in a very specific order, just like how our books on a bookshelf are in a very specific order, an order that we defined when we created it.  	let values = [5, 21, 17, 4];  Here we can see that again we created a variable, called 'values', just as we have created variables before, but this time we're initializing it to a bit of a different looking thing. The square brackets (\[ \]) represent that we are creating an array, and we may need to do this differently depending on which language we are using, but we'll keep it simple for this example. Next, inside the brackets, we have defined which values we want inside our array, and what order they are in. The first value is a 5, then a 21, then a 17, and then the last value of the array is a 4. There are a total of 4 values in this array.  ![Books on a bookshelf with index values](https://api.codesupport.dev/file/v1/images/7j4alTy6cs6bFiqzNQbm.svg)  If we wanted the first value of the array, we could access it by using it's **index** location. The **index** location is how far from the beginning of the array it is, and the beginning of the array is the very first value. This means the first value is at index 0. Looking at our bookshelf example again, if we had 4 books on the shelf, that would be like having an array of size 4. The first book has the index location of 0, because it is 0 books from the beginning (it has 0 books before it). The second book has the index location of 1, because it is 1 book from the beginning (it only has 1 book before it). The third book has the index location of 2, because it is 2 books from the beginning (it has 2 other books before it). Lastly, the fourth book has the index location of 3, because it is 3 books from the beginning (it has 3 books before it).  This is a concept that can be very confusing to many people when they first start programming, as we would all think that the first book would be at index 1, but in programming, we always start counting from 0, not 1. I think it can make it easier if you think about it as described above, where the index relates to how many values are before it. Thinking that way, the first value has no other values before it, thus it's index is 0. Now to make this reference in code, most language are going to use syntax that looks like the following:  	let values = [5, 21, 17, 4]; 	let a = values[0];  So what we have here is we created an array with our first statement, and then in our second statement, we copied the value that was at index 0 of the array and put it into the variable 'a'. Unlike when we copied the values from variables before, this time we are again using the square brackets (\[ \]), but when used this way, it denotes that we don't want the entire array, just the value at that specific index location. So what value does 'a' now have? Think about it for a minute and see if you can guess. Have an answer? Well if you said 5 then you are correct, since 5 is the first value of the array (i.e. the value at index 0), that is what was copied into the variable 'a'. You'll notice an interesting thing when you look at how these arrays are used, as this array has 4 items in it (we would say it's "size" is 4), but to access the last element of the array, you would use values\[3\]. If you were to try to do values\[4\], you would not get what you wanted at best, and possibly get an error at worst, because there is no index 4. This is something that is a common cause for mistakes in early programming, and can even trip people up now and then that have been programming for a while.  Another quick note on arrays, if you wanted to say replace just one very specific value in the array with another, how would you do that? Well, first, lets define what we want to do. We have a bookshelf full of books, and I want to replace one very specific book, with a different book, thus changing one of the values in the array.  ![Repacing a book in a bookshelf](https://api.codesupport.dev/file/v1/images/5c7DpHk3KUyEAb5HuRxp.svg)  In this example, we replaced the second book, which was at index 1, with a different book. We can do this same thing, replacing one of the values in our array. How? Well we can specify which value we want to replace the same way we did when we wanted to copy it into another variable, but this time it will be on the left side of the assignment operator (the equals sign).  	let values = [5, 21, 17, 4]; 	values[1] = 8; 	print(values);  So again, in our first statement, we created a variable put an array of values in it. In the second statement, we are saying we want to assign a new value to the second value of the array (the value at index 1 is the second value, remember that can be tricky!), and that new value is an 8. So now, if we were to print out those values as in our third statement, it would print out \[5, 8, 17, 4\]. We have replaced the second value of the array, and the old value, 21, is now gone forever.  Data types can be a bit of a complex topic at first, but they are just different ways that we want to represent data, and become very important as you move forward to write more complex code. More articles to come!

Datatypes: What they are, and how they are used.

Introduction to Programming: Data Types

It's worth taking a minute to mention output very briefly at this point, as later examples will use it to demonstrate concepts and in explanations. It is very common that we need our code to display something on the screen so we can see what it did. Think of a calculator, if you hit '5 + 5' in your calculator and then hit '=', if nothing displayed on the screen, that wouldn't be very useful! Different languages have different ways of producing output, and there are many different types of output on top of that.  For the sake of this article series, we are going to stick to the most basic form of output, which is console output, often referred to in programming as "standard out" (aka STDOUT). This is where we send data (like letters and numbers) to a console for us to be able to see it. If you'd like to know more about consoles, you can read up more about them in another article, *<link: Working with Consoles>*, but to define them briefly, they are just an interactive window that allows us to type stuff in and have stuff printed back out for us.  Consoles are a great initial output when learning programming because they are generally very simple to interact with and most languages have very simple ways of doing so. For the sake of the Introduction to Programming articles, we are going to keep it simple and use the following statement to say we want to print out to the console:  	print(x);  The "print()" is known as a function, which if you have taken trigonometry, you will have been familiar with functions (such as sin, cos, and tan!). For now, just know that when we type this statement, it will print the value stored in the variable 'x' (or whichever variable we have between the parenthesis) out to the console. So if we had the following code  	let x = 5; 	print(x);  That would print out a '5' to the console, I know, super exciting, but it's a step toward greater knowledge. Now lets talk a little more about what kind of values we end up sticking in the these variables.  Move on to read about [Data Types](/article/introduction-to-programming-data-types).

Defining Output and how it is used in Programming

Introduction to Programming: Output

# Terminology  There may be a lot of terms used in these articles that you might not be familiar with, and the best effort will be made to explain those terms as they are used. If you're curious where they come from, however, most of them have roots in mathematics, as that is mostly what programming is, mathematics. These terms are not used to confuse but are terms that are used by people in the field heavily to communicate, and it can be greatly beneficial to start to familiarize yourself with them.  # Statements  Starting with our first bit of terminology, the word **statement** will be used in various parts of the ensuing text, and it's important to understand what this means when it is used. A statement in programming is basically a single instruction that we are giving the machine. If you imagine telling someone how to draw a plus (+) sign, first you might say "Draw a vertical line". This is a statement, a single instruction that you are giving them to do something. Next you might say, "Draw a horizontal line through the middle of the vertical line". This is another statement, and with these two statements together, you have given instructions on how to draw a plus sign.  This is the exact same concept of statements in programming, with the only big difference being that statements (instructions) in programming tend to be much shorter and much simpler (and we use a lot more of them!). The machine understands only very basic instructions, and you need to be much more specific about how to do things. A single instruction that you might give someone else verbally could end up being multiple (even dozens or hundreds of!) very tiny statements when written in a piece of code.  # Variables  Variables are what we use to reference a piece of data that can have many different values. If you're familiar with basic algebra, equations are often given with certain values replaced with letters.  	y = 3x + 4  These letters are variables, they are placeholders for some value that maybe we don't necessarily know right now, but it allows us to reference them using the letter (or label) that represents them. Variables in programming serve the same purpose, they allow us to reference some value, essentially storing it inside the variable.  ![Labeled boxes](https://api.codesupport.dev/file/v1/images/xDVcRa36rtWFNWbswY52.svg)  A variable could be thought of like a box with some name or other designation written on the side. If you were to move to a new house, you would mark the outside of the boxes with labels like "kitchen" or "towels". You can put different items in that box, the same as how we can give variables different values in programming. Lets look at an example.  	let x; 	x = 5;  This example has two **statements** (remember what **statements** are from above?) with several pieces to it, starting with the first group of letters in the first statement, 'let'. This word identifies that we are **declaring** a new variable that did not exist before. If you think of our moving scenario, it would be like taking a fresh unfolded box and assembling it, taping the bottom, thus making it ready to put items in, and yet it doesn't have anything in it yet. We only need this the first time we reference the variable and never again during it's life (once the box is made you don't need to make it again!).  The next group of letters (or single letter in this case) after that is the x. The 'x' is the name we have given our variable, and it could be anything, such as 'y' or 'person' or 'address'. The name of the variable isn't important as far as the machine cares, it is simply there to remind us humans which variable it is, since it is likely we will have other variables (possibly lots!). Thinking again of the moving scenario, we had marked our boxes with 'kitchen' and 'towels' so that we can tell one box (variable) from another, which will be helpful when we go to do something with them later.  **Note: Not all languages require to you declare a variable, some will just allow you to start using a new variable right away, like PHP or Python. For these languages, we could skip this first statement entirely, and for languages where we do have to declare our variable, the way you do it can be different for each language.**  ![Naming Variables](https://api.codesupport.dev/file/v1/images/ZWDZtr8OETejku6kADsI.svg)  While the name of the variable doesn't affect how the machine runs our code, it is important to give good meaningful names to our variables so that we can remember what they are for. If you can imagine moving to a new house and your boxes were named 'a', 'b', 'c', etc., you can understand how that might make life difficult later when trying to find certain things or figuring out which boxes go where. Even the label 'kitchen' is somewhat less meaningful than it could be, as 'kitchen' could be anything from silverware, dishes, cereal, appliances, or anything that might go in a kitchen. On the other hand, the box labeled 'towels' leaves very little room for interpretation, which makes for the best type of label. This is the same for variables in programming, and it becomes apparent how important this is later when making more complex programs with lots of variables. You can read more about variable naming in *<link: Variable Naming>*.  Following the declaration 'let', and the variable name 'x', we have an interesting symbol ';' (semi-colon) at the end of our statement. This is to denote the end of our statement, and it is not always required in every language, or even used at all, but is still frequently used in many others. You can think of the semi-colon the same as if we were writing a sentence and we end that sentence in a period. With this, our first statement is complete, and with it we have said "I have a new variable, and it's name is 'x'".  On the next line we start our second statement. Now that we have created a variable, we want to do something with it. First we specify which variable we are going to use (as we may have made several others before this), which is 'x' in this case. Following that, we have what we refer to in programming as an "operator", which is the = (equals) sign. There are many different operators that we use, and the equals sign is just one of them. We should all be familiar with this symbol from math classes, as it is how we state what the value of something is. This concept is very similar to how we use it in programming, as it is used to assign a value to our variable, and as such, it is referred to as the "assignment operator". Again with the moving scenario, this is where we actually put items into the box, the lid is open and we are about to stuff something in, but what are we stuffing in? That's where we come to the final part of our second statement, the 5. This is what value we are assigning to our variable, or rather, what we are stuffing into our box. Again we end our 'statement' with a semi-colon to denote it's end, and we now have a second statement that reads "My variable named 'x' has a value of 5".  Together, we have made two statements, the first of which is "I have a new variable, and it's name is 'x'", and the next statement being, "My variable named 'x' has a value of 5". For the purposes of the prior explanations, the code had been broken into two statements, however we could have also just as easily written it as a single statement, both declaring the variable and **initializing** a value at the same time.  	let x = 5;  Both methods are valid uses, and which one you use depends on the code you need to write (more on this in other articles). Also, note the term that was just used, **initializing**. This is a term often used in programming to denote that we have assigned a new value to a variable. Also take note that you can initialize a variable many times, but you can only **declare** (reference this term from earlier in the article) it once for a given scope (read more about [Variable Scope](/article/introduction-to-programming-variable-scope). If you were to do the following code:  	let x = 15; 	x = 10;  In the first statement, we created a new variable called 'x' and initialized it (assigned it's value) to 15. In the second statement, we then re-initialized it (reassigned it's value) to 10. The previous value that used to be in x, 15, is now gone, as if it didn't exist, and x is now 10. In essence, every time you use the assignment operator (=), you emptying the variable and putting something new inside.  One last thing that we can do is instead of using a numeric literal (a literal is when we reference a value directly, such as writing the actual number 5, this will be made more clear in a bit), is we can assign the value by using another variable. So say we have:  	let x = 20; 	let y = x;  In this code, what we have done is assign the value 20 to x using a numeric literal, and then we have assigned whatever is in x to y as well. You can think of this as with our boxes scenario, when we do let y = x, we are saying, make a copy of whatever is inside box 'x', and put it in box 'y'. So now they both have the same value in them. Again, while the first statement used the numeric literal '20' to assign a value, the second statement did not use a literal, instead it referenced the value of another variable.  **Note: Assigning values from one variable to another will not always make a "copy" as we explained in this section, however when we are dealing with simple values like numbers or strings, this is most likely the behavior. **  Congratulations, you now know how to create a variable and give it a value! Continue on to read about [Program Output](/article/introduction-to-programming-output) in the next segment of the Introduction to Programming articles.

Definition of Statements and Variables and a brief overview.

Introduction to Programming: Basic Concepts

# What is programming?  Programming is just a set of instructions to tell a digital device what to do. Whether it is a blender or a super computer, specific instructions are needed in order for the device to do anything, and it will only do exactly what we tell it to do.  # What is a programming language?  Being that machines haven't learned to talk yet, we have to give them instructions by typing them out on a keyboard. A programming language is the syntax and grammar used in those instructions in order to communicate with the machine.  A machine can only speak it's native language, which is a very human unfriendly language, and one machine may have a different native language than another depending on how it was built. Writing programs in this language is very time consuming and requires a lot of knowledge. For instance, to add two numbers together, you might have something similar to this in the machine's language (Actually this is assembly, one step above the "machine's language"):  	mov eax, 14 	mov ebx, 10 	add eax, ebx 	push eax  To get around this, some smart people created what we refer to as "higher level" languages that we can use instead. What this means is we can type instructions that are closer (keyword 'closer') to the way that we would actually talk. Then we can end up with something much simpler to read (though you may not fully understand it quite yet):  	num = 14 + 10;  However, these "high level" instructions can't be understood by the machine, which only speaks it's native "low level" language, so we need to translate it, much like if you were going to translate English to Spanish. We do this with the use of interpreters and/or compilers, who's jobs are to take our instructions and translate them into the language the machine speaks so they can be understood.  # What can I do with programming?  There are many different fields of work related to programming, one of the most common among them being web application development (websites). The internet is becoming an ever increasingly more prevalent part of our lives, encouraging companies to integrate more of their services online, creating a high need for web development positions.  With the advent of smartphones came a whole new market for mini games and apps, a market that is comprised of both professional companies and individual developers writing apps of various complexities and uses.  There are also of course jobs for desktop applications as well as firmware (basically still just software) development for small devices. More importantly, there is an ever growing need for more technical workers in a variety of other fields for the sake of improving productivity. Jobs that traditionally never utilized programming are looking for people with the ability to do some basic programming to improve their overall productivity and make work more efficient.  To get started, continue on to read about the [Basic Concepts](/article/introduction-to-programming-basic-concepts) of programming.

Basic introduction into the concept of Programming

atrum's Profile

Article Feed