Arvel  Parker

Arvel Parker


VS Code April Update is Out w/ Faster Syntax Highlighting

It’s incredible what VS Code is able to do from month to month. The dev team has consistently put out features and updates every month. We’ve got 1.45 out this month with some nice additions. Add this update to the announcement of GitHub Codespaces and it’s already a great month.

#vs code

What is GEEK

Buddha Community

VS Code April Update is Out w/ Faster Syntax Highlighting
Arvel  Parker

Arvel Parker


VS Code April Update is Out w/ Faster Syntax Highlighting

It’s incredible what VS Code is able to do from month to month. The dev team has consistently put out features and updates every month. We’ve got 1.45 out this month with some nice additions. Add this update to the announcement of GitHub Codespaces and it’s already a great month.

#vs code

Tyrique  Littel

Tyrique Littel


Static Code Analysis: What It Is? How to Use It?

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.”

  • J. Robert Oppenheimer


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.

How does it all work?

Before a computer can finally “understand” and execute a piece of code, it goes through a series of complicated transformations:

static analysis workflow

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., 7Bob, 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:



import io


import tokenize



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

Samanta  Moore

Samanta Moore


Guidelines for Java Code Reviews

Get a jump-start on your next code review session with this list.

Having another pair of eyes scan your code is always useful and helps you spot mistakes before you break production. You need not be an expert to review someone’s code. Some experience with the programming language and a review checklist should help you get started. We’ve put together a list of things you should keep in mind when you’re reviewing Java code. Read on!

1. Follow Java Code Conventions

2. Replace Imperative Code With Lambdas and Streams

3. Beware of the NullPointerException

4. Directly Assigning References From Client Code to a Field

5. Handle Exceptions With Care

#java #code quality #java tutorial #code analysis #code reviews #code review tips #code analysis tools #java tutorial for beginners #java code review

Houston  Sipes

Houston Sipes


How to Find the Stinky Parts of Your Code (Part II)

There are more code smells. Let’s keep changing the aromas. We see several symptoms and situations that make us doubt the quality of our development. Let’s look at some possible solutions.

Most of these smells are just hints of something that might be wrong. They are not rigid rules.

This is part II. Part I can be found here.

Code Smell 06 - Too Clever Programmer

The code is difficult to read, there are tricky with names without semantics. Sometimes using language’s accidental complexity.

_Image Source: NeONBRAND on _Unsplash


  • Readability
  • Maintainability
  • Code Quality
  • Premature Optimization


  1. Refactor the code
  2. Use better names


  • Optimized loops


  • Optimized code for low-level operations.

Sample Code


function primeFactors(n){
	  var f = [],  i = 0, d = 2;  

	  for (i = 0; n >= 2; ) {
	     if(n % d == 0){
	       n /= d;
	  return f;


function primeFactors(numberToFactor){
	  var factors = [], 
	      divisor = 2,
	      remainder = numberToFactor;

	    if(remainder % divisor === 0){
	       remainder = remainder/ divisor;
	  return factors;


Automatic detection is possible in some languages. Watch some warnings related to complexity, bad names, post increment variables, etc.

#pixel-face #code-smells #clean-code #stinky-code-parts #refactor-legacy-code #refactoring #stinky-code #common-code-smells

Brain  Crist

Brain Crist


Why VS Code is so popular?

If you’re reading this post, I bet you know or maybe even use VS Code. This fact alone tells us a lot about the VS Code’s popularity. Millions of developers around the world from many different fields of software use this editor for their daily work. But why’s that?

In this article, I’d like to go over some of the most important reasons behind the VS Code’s popularity. We all know that the general answer is “because it’s good”, but I’d like to go deeper than that. To explore what makes a really good code editor and how it’s done!

Initial overview

For those of you wanting no fluff, here are all the reasons why I think the VS Code is so popular (in no particular order):

  • open-source
  • familiarity
  • simplicity
  • design
  • extendability

Now, some of these reasons might be less or more clear, and even overlap with one another. But even if, we’ll try to dive into each of these reasons individually.


The fact that the VS Code is (mostlyopen-source is an unprecedented advantage. Not only does it mean that the software is free to use, but also that you can help to improve it.

Another less obvious advantage of going open-source is increased community engagement. While not all VS Code users contribute to its codebase, they get a certain feeling of unity - bondage that - at least in this field - only open-source can provide.

But being open-source is an advantage far from exclusive to VS Code. Other code editors such as Atom and even whole IDEs like Eclipse or NetBeans are also open-source. So, what’s more behind VS Code’s success?


Now, this might be a little convoluted but bear with me.

I think it’s safe to say that VS Code is most popular among web developers. And it’s not without a reason. The language that most web developers are accustomed to is - of course - JavaScript. And what’s powering VS Code and with what does it integrate best? You guessed it, JavaScript!

On the inside, the VS Code is built using Electron - a framework for creating desktop apps with JavaScript with the help of Chromium and Node.js. Many web developers using VS Code are aware of and appreciate this fact. Not all do, mainly because of Electron apps notorious high memory usage and low performance, but there are still people who appreciate how meta this is - you write JavaScript in a JavaScript app!

On the other hand, VS Code utilizes its impressive TypeScript integration to power autocompletion and other useful editing features for both JS and TS. If you’re using TypeScript, it could be said that VS Code is your best bet.

So, the fact that VS Code is built on top of web technologies and also provides great support for them, makes it feel familiar and pretty much the default choice for a large portion of its growing user-base - web developers.


Without a doubt, one of the biggest advantages of the VS Code is its simplicity. From the first steps to the UI to discovering new functionalities, everything in VS Code feels simple.

With that said, I don’t imply that the VS Code is lacking in any way in terms of features - not at all. Thanks to its extendable architecture (which we’ll talk about in a moment), VS Code - even when being just a code editor - can rival the feature-set of full-blown IDEs! But, unlike those IDEs, it still manages to do it in a compact, user-friendly way.

This simplicity also shows through the VS Code performance, which is surprisingly good - especially for an Electron app. Unless you through multiple extensions at it, VS Code will feel lightweight and snappy - as all things should be.


Now, the design is usually a very subjective thing, but not so much with the VS Code. With minimalistic UI and customizable themes, everyone can find something for themselves.

I consider the UI of the VS Code clean and well-designed, without any clutter whatsoever. The only rival to VS Code in this regard is probably Atom - although it falls short in a few other areas.

As for the customizability, nearly all VS Code users have some kind of their most favorite theme. Even more than that, they can make such a theme themselves, as nearly all UI elements are customizable, and the whole process is as easy as setting values in a JSON file can possibly be.


Lastly, the advantage that many VS Code users would consider the most important - extendability. There are literally thousands of extensions in the VS Code marketplace with new ones coming seemingly every single day!

Extensions can serve many different purposes. From extension-like UI themes to programming language support, debugging, Git integration, and even Spotify players! I won’t say that there’s everything, but there’s certainly more than enough. And even if there isn’t, then you can easily make your own with the help of some JavaScript/TypeScript and detailed docs.

But why extensions are so important? It’s because they make the VS Code what it currently is - a very capable piece of software. Without them, VS Code would be not much beyond glorified text editor with good design and basic autocompletion here and there. Extensions are really important to customizing your software to suit your personal needs. It’s you who pick what features you need and when do you need them.

#vs code #software #watercooler #visual studio code #coding