Profile cover photo
Profile photo
Baptiste Pizzighini
Full-stack developper, software architect, business-aware hacker, but customer-centric evangelist above all.
Full-stack developper, software architect, business-aware hacker, but customer-centric evangelist above all.

Baptiste's posts

Post has attachment
#Javascript doesn't have types, and doesn't enforce immutability, so the following things tend to happen in almost every project I've come across:

1/ The first version is (most of the time) clean and simple. Well chosen libraries being used with the best practices.

2/ As a project grows, big refactorings begin to become more and more "dangerous". There's always the risk of having a runtime error that was not caught in dev, and will be caught in production.

3/ New changes, then, become small refactorings, mostly thin layers of code over previous code. A lot of null / undefined testing takes place, unit tests are corrected, and new ones are written.

These thin layers of code end up adding bits of complexity to the code. At first it's manageable, but, months later, the project starts getting more and more difficult to change. The worst effect on these projects is losing reliability and safety: we are not sure the application does what we want it to do, and we are not sure if any hidden bugs will make it to production.

Post has attachment
Early on, #Rust had a “green threading” model, not unlike #Go’s. [...]

The problem is that green threads were at odds with Rust’s ambitions to be a true C replacement, with no imposed runtime system or FFI costs: we were unable to find an implementation strategy that didn’t impose serious global costs. [...]

So if we want to handle a large number of simultaneous connections, many of which are waiting for I/O, but we want to keep the number of OS threads to a minimum, what else can we do?
Asynchronous I/O is the answer – and in fact, it’s used to implement green threading as well. [...]

The problem is that there’s a lot of painful work tracking all of the I/O events you’re interested in, and dispatching those to the right callbacks (not to mention programming in a purely callback-driven way). [....]

That’s one of the key problems that futures solve.

Post has attachment
In many ways ClojureScript has and continues to be ahead of the JavaScript mainstream with respect to best practices. Concepts which are only starting to break into the mainstream such as immutability, single atom application state, and agile UI development via robust hot-code reloading are old news to ClojureScript users. And thanks to the under appreciated Google Closure compiler, ClojureScript offers features like dead code elimination and precise code splitting that popular JavaScript tooling is unlikely to achieve anytime in the near future.

Post has attachment
If you've not heard of the Closure Compiler, it's a JavaScript optimizer, transpiler and type checker, which compiles your code into a high-performance, minified version. Nearly every web frontend at Google uses it to serve the smallest, fastest code possible.

Post has attachment
If you want to target a broad consumer audience, it’s safest to assume that users’ skills are those specified for level 1. (But, remember that 14% of adults have even poorer skills, even disregarding the many who can’t use a computer at all.)

To recap, level 1 skills are:
- Little or no navigation required to access the information or commands required to solve the problem
- Few steps and a minimal number of operators
- Problem resolution requiring the respondent to apply explicit criteria only (no implicit criteria)
- Few monitoring demands (e.g., having to check one’s progress toward the goal)
- Identifying content and operators done through simple match (no transformation or inferences needed)
- No need to contrast or integrate information

Anything more complicated, and your design can only be used by people with skills at level 2 or 3, meaning that you’re down to serving 31% of the population in the United States, 35% in Japan and the UK, 37% in Canada and Singapore, and 38% in Northern Europe and Australia. Again, the international variations don’t matter much relative to the big-picture conclusion: keep it extremely simple, or two thirds of the population can’t use your design.

Post has attachment
"Capsule summary of this thread: Justin Schuh finally comes out and broadcasts what security people have been telling each other for years, which is that antivirus software is one of the biggest impediments to hardening software.
I think by 2016 most people understand that antivirus doesn't work, and that it's installed more as a compliance and IT management check box than anything else.
I think people who have paid attention for the last couple years as Tavis Ormandy has published AV bug after AV bug have a good sense for the low software quality of AV systems, and understand how it creates new vulnerabilities on systems.
What I don't think we've seen is someone explaining that not only is AV ineffectual and unreliable, but that by dint of being installed across hundreds of thousands of machines and because of the kernel and runtime grubbing that AV requires as part of its security theater, AV makes it much harder to deploy OS and runtime countermeasures to attacks.
There was a Project Zero post on HN yesterday (someone can find it) about how Chrome wanted to do full Win32 syscall filtering for its sandbox processes, but couldn't, because Adobe and Widevine relied on some Win32 syscalls --- and so DRM not only doesn't work, and creates new vulnerabilities (cough Flash cough) but also makes it harder for Chrome to implement new security features that can eliminate whole classes of bugs.
Same deal with AV."

Post has attachment
Latency numbers every programmer should know

Post has attachment
Depending on who you ask, right now JavaScript is either turning into a modern, reliable language, or a bloated, overly complex dependency hell. Or maybe both?

What's more, there's just so many options: Do you use React or Angular 2? Do you really need Webpack? And what's this month's recommended way of dealing with CSS?

Post has attachment
Customers and stakeholders are the two worst source of ideas, basically because they don't know what is possible to do with technology. Yet they generally are dictating softwares roadmaps.

Real innovation comes from developpers, they should be given business KPI instead of roadmaps.

Post has attachment
This talk is about using simple values (as opposed to complex objects) not just for holding data, but also as the boundaries between components and subsystems. It moves through many topics: functional programming; mutability's relationship to OO; isolated unit testing with and without test doubles; and concurrency, to name some bar. 
Wait while more posts are being loaded