The new iphone is shipping with x86 chips for the baseband processor! https://lcq2.github.io/x86_iphone/
miniblog.
Babel is dropping the 'stage-N' presets in favour of specific plugins for features: https://babeljs.io/blog/2018/07/27/removing-babels-stage-presets
Iterating on PL features, especially with new syntax, is hard! Seems like they're striking a good balance.
Finding bugs in LLVM IR optimisers: programmatically generate small (loop free, no control flow) functions, run your favourite middle end passes, and verify the output is equivalent!
https://blog.regehr.org/archives/1510
(Uses Alive to verify and 4000 CPUs of compute.)
Awesome, there's a whole miniKanren implementation in emacs lisp! https://github.com/nickdrozd/reazon
This gives you logic programming somewhat like Prolog or Clojure's core.logic.
Fn lightning talk on using provenance data to improve Haskell type errors:
https://youtu.be/rdVqQUOvxSU
A growing range of useful collection data types for Pharo! https://pharoweekly.wordpress.com/2018/05/04/containers-now-on-github/
Good examples of Smalltalk best code practices too.
Interesting @lambda_conf talk showing how Dialyzer ('discrepancy analyzer') offers gradual typing for Erlang and Elixir: https://youtu.be/FXCMiQWnWu0
It's a neat type system: it uses 'success typing', (it assumes you're correct) and exotic features like ranges and non-empty lists!
Type signatures are optional in Haskell, but in OCaml you can even specify partial signatures (e.g. just one parameter).
Maybe return types are more valuable to annotate? I can often guess params based on the name, but I have to read the function body for the result.
Exploring making websites faster by preloading pages that an ML algorithm thinks they're likely to visit next: https://github.com/guess-js/guess/blob/master/README.md
A fun Racket library that allows you to express different retry patterns (higher-order function calls really) for unreliable functions: https://docs.racket-lang.org/retry/retry-guide.html
Really interesting to see that YouTube has shipped 'time spent' feature. However, it's out by one order of magnitude!
Fabulous article on benchmarking JIT optimised VMs: performance can vary massively, warmups can be unpredictable, optimisation sometimes hurts perf and you may not even reach a steady state!
https://tratt.net/laurie/blog/entries/why_arent_more_users_more_happy_with_our_vms_part_1.html
Git Thermite is a diff visualisation tool in Pharo: https://github.com/ronsaldo/pharo-git-thermite
Looking at the videos, you can see how the visualisations are totally integrated with browsing the modified classes! Very Smalltalk-y.
Interesting short article by Alan Kay arguing that the problem with the web is that users can't modify the pages they interact with: https://www.squeakland.org/resources/articles/article.jsp?id=1001
Learning about OCaml's OO features today.
It rather reminds me of Go: you don't need to do up-front design of what common methods your objects have. Its type is just its methods (structural typing AIUI).
You don't even need to define classes at all! Just return an object.
The qualities of great docs: https://blog.stoplight.io/writing-documentation-when-you-arent-a-technical-writer-part-one-ef08a09870d1
(reading patterns, intro text, and effective code samples!)
Apparently the dinosaur logo shown by Chrome is called the 'downasaur'. Cute!
OCaml map signatures are really weird when coming from a Java/C++ background.
For example, Java's Map<Integer, String> typically becomes string IntMap.
I don't yet have any intuition on the different tradeoffs.
Interesting discussion contrasting OCaml functors with Java interfaces: https://www.reddit.com/r/ocaml/comments/2gjcos/help_explaining_benefits_of_modules_and_functors
You can abstract over more things with functors, and they have some cool examples. Quaternions!
I also learnt that type checking modules is undecidable in general in OCaml.
Cracking the fizzbuzz coding interview with machine learning!
https://joelgrus.com/2016/05/23/fizz-buzz-in-tensorflow/
Showing 181-200 of 657 posts