HN user
Instead of regular expressions, Janet’s text wrangling is based around parsing expression grammars. Parsing expression grammars are simpler, more powerful, and more predictable than regular expressions.
I would dispute that this is the case. In PEGs, alternatives are not commutative, unlike in regular expressions. This can lead to quite frustrating debugging. While a valid choice, the advantage over REs is overstated.
native ocaml repl has landed
What does this refer to? Most people use the OCaml `utop` REPL which isn't okay for some printf debugging but nowhere near what a Lisp could do.
The repository link on that page does not work. Is there a preview?
The public transport service in Hannover/Germany once had a screensaver that you could configure to show the next departure from your nearest station. I thought that was clever marketing. Today you probably could implement this as a web service.
I like the idea mentioned in the article of exploring limited higher-order functions: functions that can only take functions as argument that themselves are not taking functions as arguments. But what simplification does this buy (in the implementation of such a language) over a language that is fully functional? It is not explained in the article.
This makes you appreciate curation in a museum. Why are these objects shown together? Historical period, size, design feature, material, production method? It looks completely arbitrary.
The main feature of interval parsing appears to be that it can jump over content such that a later part in a file does not depend on knowing everything that comes before it. Has Dogma similar expressiveness?
Filecoin, which is based on IPFS, creates a market for unused storage. I think that idea is great but for adoption it needs to be as simple as Dropbox to store files. But visit https://filecoin.io/ and the dropbox-like app that you could be willing to try is nowhere to be found. So maybe it is an enterprise solution? That isn't spelled out either. So I am not surprised that this has little traction and the article further confirms the impression.
"Show, don't tell" is lost on the authors. They only talk about visual ugliness.
The argument for annealing in the original paper is that accepting regressions is essential to escape from local minima.
https://www2.stat.duke.edu/~scs/Courses/Stat376/Papers/Tempe...
"Annealing, as implemented by the Metropolis procedure, differs from iterative improvement in that the procedure need not get stuck since transitions out of a local optimum are always possible at nonzero temperature. A second and more important feature is that a sort of adaptive divide-and-conquer occurs. Gross features of the eventual state of the system appear at higher tempera-tures; fine details develop at lower tem-peratures. This will be discussed with specific examples."
My understanding of simulated annealing is that solutions that are not improvements are still accepted with some probability in early steps but that this probability decreases as "temperature" drops. Looking at your description (but not code) I did not see that aspect but it looked like you would only accept improvements of the cost function. Is this correct or where does your solution accept slight regressions with some probability, too?
Links are unreadable in that blog post on iOS/Safari.
For covering the subject of writing, the typesetting of the PDF is remarkably poor. The mix of serif and sans serif, the font sizes don't match the structure of the document, and enumerations have inconsistent indentation - to point out just a few blemishes.
What does your business do? Stripe might not have listed your business model explicitly but could still prefer to not have you as a customer if it is an edge case.
Since list traversal is very common in OCaml, could the compiler emit code that pre-fetches the next element?
Suggestion: parse any number like 12:03 as 12 minutes and 3 seconds (and 04:12:03 with hours) and represent it as seconds. It makes working with durations a lot easier. This is just an additional parsing rule (could also use 12m3 or 4h12m3) like 1e3 for 1*10^3 but is typically not implemented.
This guy needs a copy editor. The meandering writing is off putting when someone is writing on the subject of becoming efficient at a task or process. He is in love with his own writing, maybe considering it entertainment, which he proclaims not to do.
That's a great service. I can think of various features to support more use cases:
* provide an optional label - for the use case where several clocks are used and shared.
* start and share several stop watches from a single page: start them one by one or together. For a race with multiple participants that either start sequentially or together.
* Support taking split times.
* Combine timer and stopwatch: count down from a set time, then start the stopwatch at zero. It currently does this already. This supports races like sailing where the actual start is preceded by a countdown period.
I actually really wish I had something similar for video...
Try this: https://github.com/mifi/lossless-cut
I am using the binary on macOS. The UI is a bit idiosyncratic but it works quite well and is ideal to cut a video down to the essential parts without loss of quality.
A much better effort, for anyone interested, would be to vastly simplify the OCaml build and package management story to be more Go-like.
OCaml's package management and build system is not complicated for consumers and builds are very fast. What do you feel is complicated about opam and dune?
What is complicated (but got better) is submitting packages into the official package repository. However, this ensures that packages have correctly versioned dependencies, which is good for consumers.
Go does not rely on a central package repository and this makes it easier to use by essentially just pointing to GitHub. OCaml and Go differ in the way they try to use updated dependencies for a build. OCaml by default is aggressive whereas Go prefers stability.
I’d like to see support for FIT files as they are emitted by Garmin fitness devices. It’s a clever binary format that in-stream defines the format of records which then contain the actual measurements which may be scaled for more compact representation. These multiple layers make the format not obvious to parse but the tool supports already an impressive list of formats that probably use similar techniques.
The valuation of Apple on a P/E basis is attractive and constant stock buybacks make it a safe bet. At the current scale you can’t expect startup-level growth but it is still attractive as a stock.
Likewise, look at the valuation per customer; it is around $1500, which is attractive, too.
On my Safari 14.1.2 the hero image (demo) on the landing page does not show properly. The URL is https://slacklatex.com/static/media/demo_img.5ddca5f3.webp and I assume the format is a bit too esoteric.
Compiler bugs outside undefined behaviour are not rare; calling conventions as implemented in C compilers are complex and random testing found bugs in several compilers. However, the bugs are in parameter lists and types that are rare.
As is any business that sells 1 dollar bills for 80 cents. Not a good business to own, though. "Making it up by volume" seems doubtful.
* Deliveroo lost money last year that probably provided the best possible business environment with many people willing to work for them and ordering from home during a pandemic.
* Deliveroo has basically no assets
* What is the barrier to entry for other companies? Neither riders, restaurants, or customers have any reason to stay with them.
* Deliveroo heavily depends on "self employed" couriers which quite likely courts will find are workers (edited, was: "employees") which the company needs to compensate accordingly
I find this painful to read. It's always about what Stephen Wolfram has done and how it is realised in Mathematica. If you are a true expert in a field you should have less trouble acknowledging other people's contributions. I missed, for example, the connection with Church numerals or the acknowledgement that substitution is not just defined in Mathematica.
Python is distributed in source code and it sounds like Scala dependencies are distributed as JAR files. The compatibility problems when moving compilers are not entirely unexpected, I'd say.
If you look at B in most fonts: it is not meant to be symmetric. The bottom is usually heavier, providing stability, on which the top sits. The bottom also needs to align somewhat with the x-height of lowercase characters to not look out of place - hence be taller than the upper half. Pure symmetry is not the correct measure in fonts.
I found the argument about balance within individual characters interesting: the direction of stems and the white space between them. As an example, N is shown. However, I it feels top heavy to me, almost unstable - which is not something I expected for a utilitarian font. Any comment on that design choice?