Hello, I’m Abdullah. I use this site to post stuff I make. I make a lot of tutorials (on programming/math) but I also make some cool interactive games/applications that you can play with. I’m pretty good at explaining things in a simpler manner, so you’ll be able to follow along with ease.
- Master of Science in Computer Science from Georgia Tech (specialization in Machine Learning)
- Bachelor of Science in Integrative Biology and Physiology from UCLA
Here are just some of the things that I’ve created on my free time. To reiterate, these are my personal projects, created on my own free time, not projects I did for work.
- Qt Game Engine
- A game engine written in C++ on top of the Qt framework.
- Video demonstration of the engine
- Video tutorials on how to use the engine to create games
- C++ Qt Game Tutorials
- YouTube tutorials teaching you how to use the Qt framework to make games.
- Tool of the Week
- A YouTube series in which I cover the basics of one useful software engineering (or math/engineering in general) tool every week.
- Godot Tutorials
- YouTube tutorials teaching you how to use the Godot game engine to create games.
- Kivy Tutorials
- YouTube tutorials teaching you how to create a game using the python GUI framework Kivy.
- Evolution Simulator
- Linux for non programmers
- A small book that teaches the basics of linux to non programmers.
- Heart of Programming
- YouTube tutorials on what programming really is all about (for beginners).
I really like making stuff. I love learning new things, and as a result have a pretty wide breadth of knowledge. I’m mainly into math, software engineering (engineering in general actually but my main focus is software) but I’m also very interested in biology (bioinformatics and personalized medicine in particular).
Within software engineering, I have very broad interests. I love creating software from scratch, so that I can ensure it is built the right way (readable/maintainable). I take great pride in the software that I create. Lately, I’ve been really into machine learning and data science since they are math heavy.
learning new things,
I play around with a lot of different tools, programming languages, libraries, and frameworks. Here are just some of them. These are ones that I’ve worked on recently, have a lot of experience in, or that I just like.
- Programming Languages
- C++, Python, C#
- Qt, DirectX (and Irrlich Rendering Engine), Godot Game Engine, Kivy and Tkinter (python GUI frameworks), Python’s Scientific Stack (numpy, sympy, scipy, pandas, seaborn, jupyter notebook, ipython, etc)
- IDEs/Code Editors
- Visual Studio, Visual Studio Code, Rider, CLion, Pycharm, Eclipse
I’ve been taking coursera courses on the side since I was in high school. Here are some of them:
- 6 courses on software product management
- Learned about various software processes (waterfall, iterative, scrum, agile) and practices (pair programming, on site team, no one man deeps). Then focused on scrum, which is an agile, highly iterative (i.e. you don’t do 100% of the design upfront) process, that uses working product as measurement of progress. Learned about eliciting and reviewing requirements in the form of user stories, assigning story points to user stories, breaking down user stories into managable tasks (“work breakdown structure”), having developers self assign tasks, tracking progress (release burndown and sprint burndown), sprint reviews (demo completed work to stakeholders, add new stuff to backlog, choose user stories for next sprint), daily standups (what did I do yesterday, what I plan on doing today, and any roadblocks), and sprint/project retrospectives (what went good, what went bad, how we can improve).
- 5 courses on positive psychology
- Learned about the physical and mental benefits of being optimistic, accepting what you can’t control, and taking action on what you can. Also learned about dealing with negative emotions effectively, and savoring positive ones. Learned about the PERMA model of what makes us happy, the WOOP model of acheiving your goals, and how research is conducted in psychology (TODO fill in learned research tips).
- 3 courses on embedded systems and internet of things
- Learned about the definition and challenges of embedded systems and IOT devices. Learned about microprocessors, and basic protocols they use to communicate with one another (UART, SPI, I2C). Learned about designing circuits, interacting with inputs/outputs through the pins in the arduino and raspberry pi, and the basic arduino library. TODO rewrite this paragraph.
- learning how to learn
- Learned about how to effectively learn. Covered the difference between diffuse and focused thinking and how/when to use each, techniques and practices for improving long term memory (learn before bed, sleep well, exercise, having an engaging and stimulating environment, spaced repetition), and the importance of not procrastinating (you will not remember it in the long run).
- many more! (TODO add more of my courses here)
Here are some really good books that I’ve read.
- How to Solve it
- An amazing book that taught me a general approach to solving problems, mostly in math, but could be applied to many other domains. Basically the single most important thing I got from this book was that ever time you DO solve a problem, take the time to go back and reflect/analyze the solution so that you will have an additional tool to solve future problems with. The number one arsenal you have against problems is experience solving previous problem which may be similar.Other problem solving techniques: Ask yourself, have I seen/solved something similar? Let me try to solve a generalized or specialized version of the problem first. See if I can reuse the method or solution of the similar/general/specialized problem. Have I drawn the problem? Can I draw “auxiliary” elements? Do the auxiliary elements allow me to find out more knowns to work with?
- The Pragmatic Programmer
- An amazing book which gives lots of tips on how to be a good programmer and how to write clean, maintainable, extensible code. One thing that I learned in this book was the importance of mastering text. As programmers we work with lots and lots of text. Often the input/output of our systems are text. If the input/output isn’t text then text processing is surely somewhere in the pipeline. And even if not in there, the source code itself is text! Mastering text manipulation (with tools such as IDE refactoring tools, regex, etc) is a must for all programmers. Another (little) thing that I learned in this book was the importance of using your time wisely. For example, if you are in the waiting room of a dentist office, be sure to bring a programming book with you to read :). There is no use spending that time reading a useless magazine.
- Head First Design Patterns
- Learned about the good object oriented principles (program to an interface, high cohesion/low coupling, tell don’t ask, etc) that design patterns are based upon. Added several design patterns (strategy, decorator, facade, adapter, etc) to my tool belt. Learned when to used them and when not to use them (and not to overuse them!). My favorite design pattern (and the one I use the most) currently is strategy. I seem to be using it liberally in my game engine.
- The Art of Unit Testing
- A really good book about unit testing. Covers things like how to name tests, how to write testable code, what properties make a good test, etc. For me, this book reinforced the fact that the most important aspect of unit testing is writing code that is easy to test in the first place. Code that is easy to test is modular, has explicit dependencies and gets all of its data passed into it (i.e. does not access global data). These properties allow the code to be isolated (e.g. by using Mocks) thus when a test case fails, you know exactly what class failed. Additionally the book has lots of little tips like changing random stuff in your code and ensuring that your unit tests break.
- Test Driven Development: By Example
- Learned the single most beneficial thing about tests (in my opinion) - giving the developer confidence. Giving you confidence to add, remove, and change things. If anything breaks, you will know because one of your tests fail. Additionally, writing your tests firsts, forces you to really understand your problem, and to create an API that will be easy for the client to use (because you will be using your API in your test). Summary of how to do TDD: 1) write your tests 2) run and watch them fail 3) write just enough code to make your tests pass 4) refactor (in particular focus on reducing duplication)
- How Linux Works
- Read this book when I first started working with linux. Gave me a solid foundation in using Linux proficiently. What I learned: The purpose of the various folders in the Linux directory hierarchy, the purpose/location of various Linux config files, the commonly used commands (grep, find, locate, cat, ps, ), resource monitoring commands (top, lsof, vmstat, iostat), device files and various was of accessing devices, and networking (ssh, rsh, etc).
- A Tour of C++
- Gave me a quick review of modern C++ :) There was not much that I learned from this book in particular but it was a great refresher.
- Effective C++
- Gained a deeper understanding of how C++ works and how to use its advantages while avoiding its disadvantages as much as possible. One particular thing that I remember learning in this book was about the importance of being very cautious about using inheritence. You should only use public inheritence to model an is-a relationship. Everything that applies to the base MUST also apply to the derived. You should not try to “hide” base behavior in the class as that does not model an “is-a” relationship and therefore is a misuse of inheritence.
- C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
- An awesome book that I found to be very similar to the Effective C++ series. There was actually quite a lot of overlap between the two books, which I am thankful for because it only reinforced the important points. One particular thing that I can remember off the type of my head which I learned in this book was about reducing compilation dependencies between source files. Basically it boils down to: do not “include” a file unless a) you’re inheriting from it, b) you are using it as a value member, c) you are creating an instance of the object, or d) you are accessing members of the object.
- many more! TODO add more of my books here