We shall never know the cieling that Michelangelo might have painted if he had been commisioned to paint the Museum of Science.
occasionally subtle
No title available

PR's Tumblrdome
ojovivo
$LAYYYTER
Interview Vampire Daily
cherry valley forever

Andulka

No title available
Misplaced Lens Cap

Origami Around
Sade Olutola
TMBGareOK. The Official They Might Be Giants tumblr
EXPECTATIONS
Cosmic Funnies

titsay
h
No title available
Cosimo Galluzzi
hello vonnie

seen from Ecuador
seen from Russia

seen from Bolivia

seen from Peru

seen from Türkiye
seen from Chile
seen from Pakistan
seen from Philippines
seen from Brazil
seen from Ukraine

seen from United States

seen from Netherlands
seen from United Kingdom

seen from United States
seen from Brazil
seen from United Kingdom
seen from United States
seen from United States
seen from United States
seen from Bangladesh
@iamjessu-blog
We shall never know the cieling that Michelangelo might have painted if he had been commisioned to paint the Museum of Science.
A dream about science... sort of
Last night I had a dream in which I witnessed with my naked eye The Origin of life—the initial replication—and had Dr. Lawrence Krauss and Dr. Richard Dawkins by my side and we were all blown up. It was cool. The next moment I was in the company of a gorilla. It was cool too.
That's what happens when you read these guys.
Storytelling with ‘git log’
The git log command can be a very useful tool to tell a clear story of the evolution of your Software. In fact, a single read though it can be enough to understand the how and the why of the current state of your project. Take into account the following options:
Follow a chronological order
Commit the changes in a chronological sensible order. Commits focusing on related components of your application should be recorded one after another. Following the history of a file should be as smooth as possible.
Use a clear redaction
Use both, the short and the long message features of the commit command to record a clear explanation of what, how and why has changed. Don't be afraid of being verbose. Reading the messages should be enough to understand a change, and using the diff tool should no longer be necessary.
Stay in context
Separate the commits by type and context: a refactor, a fix, a typo correction. Separate actual logic changes from coding style changes.
Branch off
By branching off, you create a sub-story of a certain change. The merge commit then indicates when that sub-story crossed paths with the main story.
A learning tool
Good organized commits can be used to teach and to learn. Think of it as a step-by-step tutorial, tracking the exact changes of a component.
Useful tools:
# Git commands git add --patch git add --interactive git commit --amend/--interactive/--squash/--fixup git rebase --interactive # Pretty log alias: git log --pretty='format:%Cgreen%h%Creset %s' --graph
After all, which of the following logs tells you a better story:
This?
Or this:
Review Driven Source-Control
Separate the code-styling and syntactic-correction commits from the actual logic-changing commits in order to facilitate a human code review.
Recomended tools:
git add --patch git add --interactive git rebase --interactive
Update:
I've created a Git hook to automatically fix and separate PHP PSR-2 coding standards issues in individual commits: Git Hook PSR-2
.gitignore global file #GitTip
Make use of a global .gitignore file to define default ignored filetypes across your projects:
git config --global core.excludesfile ~/.gitignore_global
The file can define the ignore rules for system-type files, metadata files, logs, executables, binaries, etc.
.DS_Store .Spotlight-V100 .Trashes Thumbs.db .localized .idea *.log tags composer.phar vendor/ node_modules/ *.css.map *.psd
In this way your local .gitignore file gets cleaner by focusing on the current project files only.
Here's a good collection of useful .gitignore templates.
eˆx — A broad and informal visual lifetime perspective
In this 2 hour project, I try to give a broad but informal perspective of the user's past and presumably left lifetime visualized in weekly units.
Each square represents a week on the user's life. Green weeks are weeks that the user has already lived. Gray weeks are weeks that, according to the user's figurative expected longevity, still left to live.
My objective with this experiment is that the visitor—besides having visual representation of her/his figurative lifetime—become aware of how relatively ephemeral time can be sensed, triggering encouragement to make the best out of it, week by week.
Give it a try: https://ex.iamjessu.com/
Shareio’s
I'm glad to announce the release of Shareio's. An idea that I've been wanting to develop since many years ago. Shareio's is also my first release of 2016, and a very good warm up for the many more to come. I developed it over the course of a single weekend and it involved a lot of fun. Enjoy!
git fire
Be sure to have this alias set up…
git config --global alias.fire '!git checkout -b fire && git add -A && git commit -m "fire!" && git push origin fire'
…to be used in case of fire:
git fire
Inspired by this image:
It can also be named git friday :)
Environment Variables
Store sensitive information in the server environment variables instead of config files, even if they are not tracked by your version control repository.
Having this information stored in a physical plain-text file within your application is a potential time-bomb vulnerability.
System-status broadcasting and Heartbit.at
I recently released a small side-project called Heartbit.at. It's basically a small service that consumes the official system-status information from different Internet services and retransmit it in a simpler and centralized place. Unexpectedly during the seeding part of the project I came across many surprises that lead to the thoughts I share below:
The failed Twitter list
I first attempted to create a Twitter list with all the handles of the Internet services I'm interested in. Then, my first surprise—and a prelude of what was about to come—was that I only found less than 10 major services with an official twitter account twitting about their system status. This first deception and frustration lead me to the idea of creating Heartbit.
The missing status page
With a bigger and perhaps a naive hope, I started to code directly on the project. When the seeding part came I found something similar: many major internet services don't even have an official system-status page nor anything similar.
So I ended up consuming data from all type of channels in all type of formats: RSS feeds, Twitter accounts, blog and Tumblr sites, API calls, etc.
The problems and the opportunities
So after all the struggle, I moved on and finished and published Heartbit. It is up and running fine. But I'm not comfortable with the feelings those surprises left on me. The possibilities of improvement for this industry are huge if these, not yet seriously identified problems were addressed correctly. The most important points I consider that must be standardized are the following:
Status page
Every major service should have an official status page with at least up-time metrics and events history. Many end-users may not look or understand this information, but the people relying on those services will do, and will definitely find it useful. Having a system-status page for an Internet service should be a standard.
Subscription feed
An RSS or Atom feed should also be available for consumption. The objective is to have a human-readable channel available to be informed. Just like the status page but without the necessity to visit the page. In this way interested users can subscribe to the feeds of the services they care and be informed in a centralized application: the feed reader.
Status API
A system-status API should also be available for systematic and automatic consumption, not for humans. Companies and technical users could build their own tools to consume the information and propagate it in the way it works better for their organizations. Not to mention that automated actions can be build upon that, but that comes next.
Subscription Webhooks
I consider this point to be the most important and the one with the higher potential to improve the whole thing. Allowing a subscription-model for transmitting real-time status of the different levels of the infrastructure or components of a service, will allow dependent services and businesses to build up tools that can automatically react to highly affecting events. Just think a bit on that. The benefits are huge.
Here's a simple example: Imagine a merchant running its business on an e-Commerce system which depends on a payment bridge service such as Stripe for its checkout phase. If at some point the credit card systems of Stripe goes down, Stripe will automatically trigger the webhook and send the notification to all subscribed dependent services. The e-Commerce system will then receive the event allowing it to automatically and in an instant switch the payment bridge provider to another service such as Braintree or PayPal. In this way, the checkout will not be interrupted for the customers and the business will continue for the merchant. Perfect!
The social layer
Broadcasting this information on the social channels should be also present. Keeping the end-user informed about issues on the layers that affect their direct interaction and experience with the services can potentially decrease the number of technical support tickets and calls.
The textual format
Having a standardized textual format for redacting the events, or at the very least, the status value of an issue ("updated", "resolved", etc.), will make it easier to consume, automate and understand.
Conclusion
It is well known that on each day our routines, tasks, infrastructures and services rely more and more on even other infrastructures and services. And due to the "nature" of computers and systems, we cannot take for granted that failure will not happen. By being prepared to correctly handle that failure we will drastically diminish its very own chances of happening in the first place.
--
This note was mirrored on Medium: @JesusLeon.
Heartbit.at
I just released a side-project called Heartbit. A small service to watch the official system-status of different Internet services.
A dedicated post on regarding the development part will come next.
Prinzipalmarkt.
© Jesus Leon.
https://instagram.com/p/7cxwB-CzxE/?taken-by=iamjessu
Nomenclature is First
A well designed and engineered software must have a clearly defined nomenclature.
As your software grows and evolves, its nomenclature is the key to have a standarized and eloquent API.
The nomenclature is the linguistic framework of your software.
Clients and their Systems
Making sure your clients understand their systems will set a conceptual-solid path for any type of future request.
This will avoid unnecessary confusion and stress when reviewing concepts, functionalities, etc.
Master Your Tools
Take the necessary time to understand, learn and setup your working tools even before learning the technology you will work with.
A clean local environment is an efficient environment.
Analogy: How many minutes does a chef spend looking for the fillet knife or for the pepper? None!
Have your environment ready to perform whichever task you need by just pressing the minimum necessary keys.
Learn to fail
The more ready you are to handle failure, the more success you will achieve.
Failure will happen. Be ready to transform it into success.
Distributed Git Bare Repos
Distribute your bare repos among a hanful of other trusted services or owned servers so when your primary service (mainly GitHub) is unreachable, you can still evolving the project as a team.
Not to mention if you depend on it for other tasks or phases of your development such as CI, deployments, etc.