Hey there! Welcome to my blog where I post about my journey as a self-taught developer. You can find my GitHub by clicking HERE.
Have you ever worked in a paper based office? I’m talking no automation, post-it notes, printing every single document and placing them into Manila Folders, no sense of electronic order. This is a place where there is no Dropbox, there is no CRM and even the payment gateway (Stripe, Authorize.net, Braintree) was non-existent until 2015.
I had trouble finding a relevant photo on pexels.com, ha! So I took a picture of the file cabinet room at my current job. This friends is 1970’s still cranking in 2021. I’m not saying that this a good thing, on the contrary. It is incredibly time consuming and difficult to maintain good reviews and satisfy clients without a lot of extra effort and monthly burn out.
You may be thinking, “why the post James?”
On November 15, 2015 I received a book in the mail I ordered on Amazon. It was John Duckett’s HTML & CSS. I did not know at the time, but this book was the key to me becoming completely immersed in Web Development, and it was the way out of a paper mess for myself, my co-workers and my employer.
Without going into detail of our old and current workflow, I will explain some of the key benefits I’ve experienced hands-on, as a developer in the insurance industry and how I have automated some of the office daily tasks with two specific applications
#codebase #paperless-solution #leave-job #python-flask #automate
Let’s face it: people are impatient by nature and most likely want things to happen faster in their lives. I would apply the same to code learners. Students, when starting to learn programming, first wonder how to speed up the training and make a career as a programmer as soon as possible.
I am not the one who convinces everyone that learning to program is a lightning-fast journey — the other thing is that it is not as difficult as people think. All boils down to interest, passion, regular practice, and patience, of course. I also often recommend different online and offline resources to my students to make their learning process easier, more effective, and faster. And in this post, I will share a few tips with you.
These tips are not magic pills and probably won’t make you a professional developer in a week, but they will definitely make your life easier, while the learning process won’t be that intimidating, vague, and boring. Besides, following all of them together may speed up training.
So, without any further delay, let’s get to them.
No matter how simple a new subject is, it still requires you to consolidate your knowledge. Starting to play with code soon after you’ve completed the next section helps you learn the given concepts faster and feel confident when writing your first line of code. Fortunately, the web is full of platforms, where you can start practicing shortly.
Let’s consider them in detail.
#coding #learn-to-code #learning #programming #learning-to-code #machine-learning
Everyone makes mistakes, not just beginners, but even professionals. This article goes over a dozen common mistakes that Java newbies and newcomers make and how to avoid them. Have you or your colleagues made any of these common Java mistakes early in your career?
Everyone makes mistakes, not only learners or beginners but professionals. As a programming course, the CodeGym team often collects mistakes of newbies to improve our auto validator. This time we decided to interview experienced programmers about mistakes in Java they made closer to their careers start or noticed them among their young colleagues.
We collected their answers and compiled this list of dozen popular mistakes Java beginners make. The order of errors is random and does not carry any special meaning.
#java #learn-java #java-programming #beginners #beginners-to-coding #learning-to-code #learn-to-code #learn-to-code-java
The story of Softagram is a long one and has many twists. Everything started in a small company long time ago, from the area of static analysis tools development. After many phases, Softagram is focusing on helping developers to get visual feedback on the code change: how is the software design evolving in the pull request under review.
While it is trivial to write 20 KLOC apps without help of tooling, usually things start getting complicated when the system grows over 100 KLOC.
The risk of god class anti-pattern, and the risk of mixing up with the responsibilities are increasing exponentially while the software grows larger.
To help with that, software evolution can be tracked safely with explicit dependency change reports provided automatically to each pull request. Blocking bad PR becomes easy, and having visual reports also has a democratizing effect on code review.
Architectural analysis of the code, identifying how delta is impacting to the code base. Language specific analyzers are able to extract the essential internal/external dependency structures from each of the mainstream programming languages.
Checking for rule violations or anomalies in the delta, e.g. finding out cyclical dependencies. Graph theory comes to big help when finding out unwanted or weird dependencies.
Building visualization for humans. Complex structures such as software is not easy to represent without help of graph visualization. Here comes the vital role of change graph visualization technology developed within the last few years.
#automated-code-review #code-review-automation #code-reviews #devsecops #software-development #code-review #coding #good-company
In the fall of 2012, I walked into my graduate advisor’s office and asked her which computer science class she recommended for me to enroll in. I explained that I was a complete novice in programming. She suggested Introduction to C Programming.
After attending a few lectures, I discover that the majority of the students I spoke to in this introductorycourse had some prior experience in programming.
Six weeks and 80 hours of work later, I dropped the course.
Static code analysis refers to the technique of approximating the runtime behavior of a program. In other words, it is the process of predicting the output of a program without actually executing it.
Lately, however, the term “Static Code Analysis” is more commonly used to refer to one of the applications of this technique rather than the technique itself — program comprehension — understanding the program and detecting issues in it (anything from syntax errors to type mismatches, performance hogs likely bugs, security loopholes, etc.). This is the usage we’d be referring to throughout this post.
“The refinement of techniques for the prompt discovery of error serves as well as any other as a hallmark of what we mean by science.”
We cover a lot of ground in this post. The aim is to build an understanding of static code analysis and to equip you with the basic theory, and the right tools so that you can write analyzers on your own.
We start our journey with laying down the essential parts of the pipeline which a compiler follows to understand what a piece of code does. We learn where to tap points in this pipeline to plug in our analyzers and extract meaningful information. In the latter half, we get our feet wet, and write four such static analyzers, completely from scratch, in Python.
Note that although the ideas here are discussed in light of Python, static code analyzers across all programming languages are carved out along similar lines. We chose Python because of the availability of an easy to use
ast module, and wide adoption of the language itself.
Before a computer can finally “understand” and execute a piece of code, it goes through a series of complicated transformations:
As you can see in the diagram (go ahead, zoom it!), the static analyzers feed on the output of these stages. To be able to better understand the static analysis techniques, let’s look at each of these steps in some more detail:
The first thing that a compiler does when trying to understand a piece of code is to break it down into smaller chunks, also known as tokens. Tokens are akin to what words are in a language.
A token might consist of either a single character, like
(, or literals (like integers, strings, e.g.,
Bob, etc.), or reserved keywords of that language (e.g,
def in Python). Characters which do not contribute towards the semantics of a program, like trailing whitespace, comments, etc. are often discarded by the scanner.
Python provides the
tokenize module in its standard library to let you play around with tokens:
code = b"color = input('Enter your favourite color: ')"
for token in tokenize.tokenize(io.BytesIO(code).readline):
TokenInfo(type=62 (ENCODING), string='utf-8')
TokenInfo(type=1 (NAME), string='color')
TokenInfo(type=54 (OP), string='=')
TokenInfo(type=1 (NAME), string='input')
TokenInfo(type=54 (OP), string='(')
TokenInfo(type=3 (STRING), string="'Enter your favourite color: '")
TokenInfo(type=54 (OP), string=')')
TokenInfo(type=4 (NEWLINE), string='')
TokenInfo(type=0 (ENDMARKER), string='')
(Note that for the sake of readability, I’ve omitted a few columns from the result above — metadata like starting index, ending index, a copy of the line on which a token occurs, etc.)
#code quality #code review #static analysis #static code analysis #code analysis #static analysis tools #code review tips #static code analyzer #static code analysis tool #static analyzer