I personally watched Scott spend years working on the project and obsessively iterating on the steel, the vibration pattern, the circuitry, the handle, and the form factor. Scott is a hacker, one of us for sure. I mean, the guy built a custom robot just to measure cutting efficiency...
The knife is amazing and exactly as shown in the video. Rand Fishkin has a nice short on LinkedIn trying out the knife too. I think he shows one his (sharp) kitchen knives slicing through a lemon, then the Ultrasonic. It's astounding.
Disclaimer: I am a (tiny) angel investor in Seattle Ultrasonics.
Does that video show him doing actual prep? I 100% believe he made a knife that can make a paper-thin slice of a lemon. But that's not what a chef's knife is for. As someone who thinks the world would be a better place if this product worked and was successful: for god's sake record someone processing an onion. That's what matters.
In Rand's video he does an "old" lime, mozzarella, and a shallot. It's just a quick vid he did in like five minutes but it shows some prep. Rand is a prolific amateur chef...
So, I just watched this, and he's not processing a shallot, he's just slowly talking thin slices off it. Also: even when my MAC is rolled over and needs a hone, it still does a lime just as well.
I'm not saying this knife doesn't work just that I'm noticing that none of the videos show it working.
Seriously, it is only a little bit of an exaggeration to say that the entire job of a chef's knife is to quickly process an onion. What's especially weird is that even an inert knife with its factory edge will show well in an onion dice video!
If thats the actual best demonstration thats not good at all. Like either he is the worst cook ever or the knife is actually difficult to go down straight with..
Im sorry but the video feels a bit disingenuous with the way he is cutting the lime. With the normal knive he just pushes straight down on the lime and with the vibroknife he actually does a slicing move. Same with the cheese. It doesnt feel like an honest comparison
Maybe, though I'll note that this matches how I use regular knives with cheese & similar things: with a dull unscalloped knife I have to carefully go straight down to avoid tearing. If my knife is sharp (or temporarily oiled) and the food doesn't stick, I'll slice. Because I can. The end result is different: thinner slices, less crushing. Also faster.
I saw the same thing immediately. The robot arm could be calibrated to use a real slicing motion as well. They're misrepresenting the actual performance of this product.
Even the best tend to struggle with consistency and can only go so thin due to all the friction. An ultrasonic mandoline that can overcome all that would probably fly off the shelves and better match the original industrial intent.
On one hand I would buy that instantly. On the other hand, it’s already missing small pieces thanks to my current mandolin. Not sure I want to make my scariest utensil scarier.
I have used this knife, I am an angel investor in Scott's company. The thing is legit amazing. He labored for years to bring this to market and it shows.
Static analysis through type hints brings plenty of benefits to a dynamic language, such as helping to eliminate bugs at runtime (albeit not perfectly) and making it easier to grok a codebase. It’s a trade off and Ruby is as dynamic as it gets. But there is a point to it
My beautiful experience with sorbet: Yeah, ducktyping? We don't do that here.
Depending on a library that uses ducktyping (like any sane library following the Ruby conventions)? Good luck writing a wrapper for it. Or just disable type checking.
This goes so much against the Ruby vibe that I advise you to just go and use Rust instead if you hate Ruby that much that you want to butcher it with types.
Sorbet has its flaws. I didn’t like it either. Having used TypeScript extensively, there is a way to do it right and a way to do it wrong. I’d classify TypeScript as the ideal way to introduce static types into a very dynamic language, given its extensive flexibility to handle dynamic features in a language (e.g. smart type inference, ‘is’ keyword, very flexible generics). Sorbet doesn’t have a lot of those features
Ruby has a strong history and tradition of TDD/unit testing. This is partially a crutch for its lack of static type analysis. Ultimately checking for bugs before running code is very useful
You use typed variables/typed function signatures when it's convenient, they give you some compile-time contracts, easy documentation and probably even speed. Otherwise they don't exist. I don't do Ruby, but Gradual Types/Type Inference is a no-brainer for dynamic languages, practically no drawback, only benefits. (And popular statically typed languages such as C/C++, Java, Rust support Type Inference, or are going there too.)
Cool. People who want gradual typing can use those and leave Ruby alone.
> I don't do Ruby
So why have an opinion?
Languages I use: Ruby, C++, Odin, R. I'm not about to to around telling Rust, Python or Typescript people they're doing their languages wrong, even if there's things I hate about those languages. I just don't use them.
Ruby already has this with Sorbet. Nobody is forcing you to use it, are they?
It seems you have a lot of opinion here without really discussing your problem with type hints though. What is it you dislike?
I use Ruby regularly, have used it for more than a decade, and I wish it had something like a TypeScript equivalent (Sorbet is sorta this but not enough). Every time I work with a Ruby codebase without Sorbet, it’s a lot of guessing and praying that test coverage is good enough. It’s not fun having to find out in prod there’s dumb bugs that would have been caught by static analysis. Something I experience virtually never in TypeScript, the other language I’ve also used for a decade
> It seems you have a lot of opinion here without really discussing your problem with type hints. What is it you dislike?
It's runtime overhead (or you make a transpiler which then makes the language less dynamic), makes metaprogramming more annoying (other languages solve this with an "any" type which just defeats the purpose), and the "problem" it solves can be solved with tests which you should be writing anyway.
I do use statically typed languages BTW, I just prefer that if I'm going to go through the rigmarole of types that I'm going to get some actual benefit, namely an order of magnitude more performance.
My opinion is probably this since I don't work for a large corporation, I have my own startup, so I value my time a lot. I'm ok with trade-offs, I just think adding type hints to a dynamic language isn't a good trade off; it's almost all downside.
Edit:
> guessing and praying that test coverage is good enough.
For me, at least with TypeScript the single biggest advantage is the hinting you get from 3rd party packages/modules. This goes for building modules as well, you can use jsdoc directly, but it's even more cumbersome than TS imo.
It's kind of annoying that static type introspection has become the norm for language servers because live environments are so much better. With Ruby you have the REPL and there have been IDEs and tools that allow runtime reflection which is just so much better (think Lisp or Smalltalk). LSPs are nice for static languages but compared to live environments they're a step down...
Even after over a decade with TypeScript, I'm still kind of mixed on it... there are a lot of times where trying to wrangle typing is more painful than it should need to be... I'll often just cast to any, then I have to add a comment to suppress the error message with the default config. I use deno a lot and tend not to mess with the default configuration there. Even with node/npm, I still don't do much with the tsconfig beyond what a minimal need is.
It's not as painful as earlier versions and is generally okay to work with... but there are definitely times you need to work around the typing as opposed to with it. For example extending/using context in hono/oak/koa so you get hinting, but want your endpoint handlers in separate modules. It gets very messy, very quickly.
Sorbet can actually make programs crash at runtime if a variable's type doesn't match its annotation, right? It's not as busted as some other gradual typing implementations.
I'm definitely in favour of gradual typing but runtime checking is already really easy to do if that's what you want. Just add a rightward assignment patten match to your method. e.g.
def somemethod(foo, bar)
foo => Integer
bar => MyBarClass
end
Personally I think the RBS-Inine format is the way forward. Sorbet has experimental support for it too.
Many smart engineers (including Guido) disagree with you, and have added static types to Python, Javascript, Dart, Elixir, Hack and surely some I'm forgetting.
This is neat, thanks for posting. I am using memo_wise in my current project (TableTennis) in part because it allows memoization of module functions. This is a requirement for my library.
Anyway, I ended up with a hack like this, which works fine but didn't feel great.
def some_method(arg)
@_memo_wise[__method__].tap { _1.clear if _1.length > 100 }
...
end
memo_wise :some_method
This got some attention in r/ruby so I figured I'd post it here too..
TableTennis is a new gem for printing stylish tables in your terminal. We've used ad-hoc versions of this in our data projects for years, and I decided to bite the bullet and release it as a proper gem.
- auto-theme to pick light or dark based on your terminal background
- auto-layout to fit your terminal window
- auto-format floats and dates
- auto-color numeric columns
- titles, row numbers, zebra stripes...
By far the hardest part is detecting the terminal background color so we can pick light vs dark theme for the table. This requires putting the console into raw mode and sending some magic queries. These queries are widely supported but not universal. There are some great libraries for doing this in Go & Rust, but as far as I know nothing like it exists for Ruby. Check out the long comment at the bottom of this helper if you are curious:
Hi Jeff, thanks for creating mise! I am gearing up to migrate from asdf, very excited to check it out. Not totally sure we can adopt mise for tasks (we use just) but willing to give it a whirl. Putting run commands into toml sounds like it might be challenging, I wonder if there's syntactic sugar that would help.
most people just put simple tasks into toml (like `npm run test` or something), for anything complex, file tasks are much better: https://mise.jdx.dev/tasks/file-tasks.html
file tasks are basically just a directory of bash (or whatever shebang) scripts, but special comments give them extra functionality like dependencies or defining flags/options.
Actually, it was package.json scripts that pushed me toward just! I wanted that stuff in non-node projects (python/ruby/~), I wanted more complicated scripts, I wanted more logging output, I wanted comments... For whatever reason every project seems to have 10-20 little commands (often interdependent) and just makes that a breeze.
The knife is amazing and exactly as shown in the video. Rand Fishkin has a nice short on LinkedIn trying out the knife too. I think he shows one his (sharp) kitchen knives slicing through a lemon, then the Ultrasonic. It's astounding.
Disclaimer: I am a (tiny) angel investor in Seattle Ultrasonics.