CodeIsGo.com

Alexis Mangin deep dive on a good architecture for very large web applications in React. if you didn’t start with a good architecture, it can become difficult to keep your code organized.

Author spent time comparing solutions from Nathanael Beisieg and others but decided to go with his own approach. He also compares common boilerplate projects on GitHub. They often organize all the files by type, but many of them do not account for application grows; and it often becomes difficult to maintain it later.

He takes liking in Ember and it’s ability to structure your project by features, instead of by type. Author decided to group all related features together, and nest them as needed. Recommended way is to create services to manage all api requests.

Code with examples in ReactJS provided. Excellent article!

Tomek Kaczanowski journey into explaining what you do at work to a group of 6 years old kids, how to explain programming to them in engaging and funny way. Interesting article built on ideas for a successful presentation:

• Keep children them engaged by asking questions and drawing (big drawing, drawing while talking).
• Build upon what they already know (YouTube, laptops, tablets, DVDs).

All children new about laptops of their parents, smartphones, tables and often consumed content over the internet. Author explained in simple ways (drawings) what computers are, how they work, that they use a funny language which consists only of zeros and ones. Methods which worked are also mentioned, e.g.:

• Drawing pictures is the right way to go - grabs their attention.
• Be prepared for repeating things over and over again.
• Write carefully - e.g. they will protest when you write 1 so it looks like 7.
• ~25 minutes is enough; their attention span is simply too short.
• There is no point in correcting them about technical details, important is to understand the concept.

Very interesting and educational.

Anup Cowkur post on topic: why not use some of the concepts and techniques from the functional world in Android programming.

The term Functional programming is an umbrella for a range of programming concepts which the moniker doesn’t quite do justice to. At it’s core, it’s a style of programming that treats programs as evaluation of mathematical functions and avoids mutable state and side effects. Declarative, Explicit and Concurrent code that is easier to reason about and is designed to avoid surprises.

Authors then describes how to use pure functions. A function is pure if its output depends only on its input and has no side effects. Code examples demonstrating functional programming in both Java and Kotlin are included… Good reading.

Tom Goldenberg nice article pointing out why JavaScript deserves respect. JavaScript the most widely used computing language.

However, JavaScript still doesn’t command the same respect that other languages do. JavaScript is increasingly being used in aspects of software development other than stylistic effects — for example, backend tasks, web servers, and data processing. JavaScript “is the result of evolution, not design…”

Author analyses growing ecosystem, job opportunities for JavaScript engineers in US and also considers criticisms of JavaScript. JavaScript has come a long way in the past 5 years. In the last 2 years, the technology for sending JavaScript code to the browser has improved dramatically (see: webpack).

Although JavaScript may have started as the language of the browser, it is becoming more ubiquitous in all aspects of computer science — the web, mobile, IoT, and back-end services… Good reading.

Brandon Morellinot complicated tutorial aiming to build a simple Twitter favorite bot with Node.js in just 38 lines of code.

You will learn how to create a Node.js application that interacts with the Twitter API. In this application, the API will allow us to search for tweets, and favorite the tweets that our application finds. It will guide you how to register your app with Twitter.

It will also teach you how to create project and package.json in Node.js. The workflow of the bot app is very simple" first, you search for Tweets, then you select one and favorite it.

The full app.js file is provided on GitHub. And there is also second article in the series which will show you how to do a lot more with Twitter API.

Jacques Mattheij has written neat article on topic of improving legacy code. It happens to everybody - you get handed legacy code, quite often without proper documentation or hopelessly out of sync with what is presently keeping the company afloat. However it can be a lucrative business to be able to take such a code and to turn them into healthy maintainable projects.

Author suggests the most sensible approach is to work incrementally. Article pays attentions to importance of:

• Backups, especially configuration data
• Having build process and that it actually produces what runs in production
• Writing the tests
• Instrumentations and logging
• Changing only one thing at the time
• Using proxies between end-user and the old system
• and more

In a situation like that author prefers total control and an iron clad process. Can not agree more.

Neil Madden has written about best practices for JSON Web Tokens (JWTs, pronounced “jots”). JWTs are popular as a way to securely transmit small packets of information, such as session tokens, proof of identity, and network protocol messages.

You will find best practices to ensure that your information stays secure. Taking some time to learn about the security properties and how the underlying cryptographic primitives provide them will pay dividends in the long run.

Authors considers also the fact that JWT libraries provide a lot of confusing options. These options can be bewildering at first, and you need to pick carefully to get the security properties you desire. The weakest part of any system’s security is often the key management - Neil will point you in right direction how to manage them properly.

The JWT specs contain Security Considerations sections that detail common threats and advice on how to avoid them; you will find links to them in article and you should read all of these and make sure you understand them before deploying a JWT-based solution. Links to common criticisms of JWT-based solutions are also included.

Recommended reading!

Antero Taivalsaari and Tommi Mikkonen posted an article about emergence of millions of remotely programmable devices in our surroundings will pose significant challenges for software developers.

The emergence of IoT means our everyday things—light bulbs, door knobs, toothbrushes, etc. will become connected and programmable dynamically.

Article describes, or mentions in length:

• The emerging common end-to-end IoT architecture
• What makes IoT development different
• Implications and challenges for software development
• Fallacies of distributed computing
• Inadequate languages and tools
• The dynamic nature of iot systems
• Security

Authors believe the IoT’s future lies in the ability to orchestrate and program large, complex topologies of IoT devices remotely. The Academy of Finland (project 295913), Mozilla, and Nokia Technologies have supported this research.

Adam Neary’s neat article about rethought the architecture for the JavaScript side of the codebase at Airbnb. This post looks at the product drivers that precipitated the change, the steps we took to move away from their legacy stack and some of the key pillars of the new stack.

Airbnb sees more than 75M searches each day, which makes the search page their highest traffic page. To enhance their search experience they needed to break free of the legacy (Rails) page-by-page approach. The process of transition from legacy to new stack is described in detail with lessons Airbnb learnt in the process.

They use Hypernova to server-render React. They also use an AsyncComponent as a way to load sections of the component hierarchy after mount.

Interesting read with React code examples.

Chris Tomich post aiming to explain Go strings and their relationship to runes and bytes in a compact way.

He tries to point out two really important fundamentals of strings that need to be understood to mastering strings in Go.

• the components of a string
• the slice behaviour of a string

The first important rule of strings is that strings are made of up runes (not bytes). It’s important to understand that runes represent a single character and that different languages have different definitions of what constitutes a “character”. Also ranging over a string with a for loop returns runes.

We recommend to read whole article. Code example provided in the text.