Weston Pace

I've just deployed my first space on HuggingFace! This space is using a specific T5 that was trained for topic classification. I'm just amazed at the speed that one can deploy a streamlit app - without any docker and minimal configurations thanks to HuggingFace! I also minimize code duplication by installting my main repo and slapping its url in requirements.txt Next step - the inference is pretty slow - 280M parameters inference is not a walk in the park. I think I need to tweak some configurations to improve on this https://lnkd.in/dWKScD5U

13

Learning to Rank is Back on the (Reddit, Inc. Eng Blog) Menu Boys!! In this post by Chris Fournier we discuss some of the infra challenges for Learning to Rank in Solr

62

It seems that with C/C++ -> Rust, specifically, you could do this by comparing the output compiled code as one of your verifications of correctness for ML learning This is something that e.g. copilot doesn't do - but it'd be straightforward to do so when doing training The expectation would be that the compiled rust code should be equivalent to the compiled C code, i.e. the assembly should be semantically no different As the ML learns, it may end up doing some funky rust code simply to get that to match - but that's probably a good thing, as this is the part that would require some manual intervention & you'd at least be guaranteed equivalent behavior

1

The subject of support for incremental reads of mutable tables and generating CDC streams in the four table formats I'm covering is far more nuanced than I expected. What was going to be one post is going to have to be a 5 parter to keep it manageable: 1. Introduction to the concepts 2-5. Apache Iceberg, Delta Lake, Apache Hudi, Apache Paimon

15

2 Comments

Hey folks! I'd like to more formally introduce and talk about a few of the projects we're working on towards improving large-scale bioinformatics analyses (one of which was developed during St. Jude's KIDS24 Biohackathon)! If you're not aware, my team started a project called St. Jude Rust Labs (https://lnkd.in/eXY_9dJ8) where we're rewriting a more foundation for bioinformatics analysis in Rust. This cuts across more than just workflow execution, but, recently, we've been primarily focused on improving the experience of working with the Workflow Definition Language (WDL) at scale. To that end, we've released a number of projects, including: - We've written a complete lexer/parser for WDL v1.2 language (https://lnkd.in/eGWHSM2g). Anyone can use this foundation to build tools for WDL. - We've written a VSCode plugin that includes a language server protocol (LSP) for linting and validation directly in your editor (https://lnkd.in/euApG9tF). - And, announcing today, we've started down the road of writing our own WDL execution engine spread across the Crankshaft (https://lnkd.in/et_RFkA3) and Sprocket (https://lnkd.in/eUTuPE68) projects. Crankshaft was prototyped during the St. Jude Biohackathon last week—it's a _headless_ workflow execution engine, meaning that, in theory, others could come along and write drivers for Crankshaft built on NextFlow, CWL, Snakemake, etc. As I said earlier, our team is really focused on WDL specifically, so we're going to continue building out a "head unit" for Crankshaft using WDL. That being said, I would love to see other community projects popping up and using the core machinery for other workflow languages. Thanks to all of the individuals who participated on our Biohackathon team (Kevin Benton, suchitra chavan, Braden Everson, Andrew Frantz, Michael Gattas, Peter Huene, and John McGuigan)!

76

1 Comment

So far summarization has been the killer AI app for me. Others like code generation have been less impressive in my experience. But it’s really really good at distilling down text to a useful summary. A few places I’ve seen that include a slack bot that summarizes a slack thread, forums that summarize long topics, incident.io incident summarization, and asking ChatGPT to summarize or pull information from a document I upload to it.

27

3 Comments

Having a ton of fun writing an ORM for V2 of Case Kit. Typescript has such an incredible type system. I have autocompletion for column names, the ability to include relations, relations of relations, etc etc etc... all returning properly typed data (no classes in sight). It's been really satisfying seeing it coming together, and it's been great getting my hands dirty with some (relatively) complex generics. And to head off the obvious question… why aren’t I just using Prisma? Well there’s a couple of things I’m doing differently that I think are marginally better: there’s no code generation involved here, it’s just types (inspired by Drizzle); there’s no Rust binary you need to deploy, and it hews much closer to Postgres behaviour and syntax (the aim here is not to abstract away which database you’re using). But the real blocker to me using Prisma was that its extensions don’t support modifying queries of nested relations - a hard requirement for me due to the way I have multitenancy and soft deletes set up. It’s not shown in the video but the Case Kit ORM lets you write simple middleware that will be applied to every level of a nested query. Perfect for setting timestamps or adding clauses on tenant id or things like that.

22

Geoffrey Hinton's contributions is significant enough that I won't quibble with the category for his prize. (Nobel committee could create a special category just for him for all I care.) Widely (and rightfully) recognized as a leading expert in deep learning, his research touches everything from * Foundational concepts such as backprop https://lnkd.in/gMunbBzA * Foundational model architectures such as AlexNet https://lnkd.in/gq2JPJ6h * Optimization algorithms such as Momentum and RMSProp * Visualization techniques such as t-SNE https://lnkd.in/gjuw3vhA I don't think it's possible to overstate how profound the impact of machine learning and artificial intelligence will have on society, promising to unlock discoveries, improving productivity. Even ideas about what mastery of language or reasoning means, will need to be re-thought. Professor Hinton deserves all the credit for all of this.

31

I find interesting the hype about counting downloads for a given tool as a metric for success. I guess it helps to show how popular something is, but I would love it if people also considered other aspects, such as project governance and project activity. Anyway, let's follow the trend (evidence in the comments): - Selenium Java downloads: 98.5M in May 2024 - Selenium active users in the last 30 days: 2.6M. Happy automation!

54

9 Comments

🏎️💨 Making of a Ridiculously Fast™ API client in R. Why my package is **~17x faster** than the community alternatives that call the **exact same API endpoints**. 👇🏽**design choices matter** ✨ https://lnkd.in/ggi_2XyQ

129

2 Comments

I’ve recorded a few episodes of a new show I’m calling Commit History. Each 15-to-30 minute episode examines an interesting commit to a significant open source project. So far, we’ve examined things like how NodeJS added the fetch API, how a 25 year-old bug in Firefox finally got a fix, how the Zed editor sped up “select-all-matches” by a factor of 250x in a 75 line commit, and we’ve read commits in languages like Javascript, Rust, C++, Ruby, and Zig, with more to come. A lot of us got into engineering because of our curiosities - which led to tinkering, sometimes destructively, but always starting with an observation, asking ourselves “How?”, and pulling out the tools - either screwdrivers or terminal windows, and not stopping until we got an answer. I’ve long assumed those days were behind me, but recently I reflected on how often I dive into open source code, sometimes because an unexplainable bug keeps popping up at work, or documentation is lacking, or a top story on HackerNews caught my attention - and I find myself right back into that hacker mindset, digging deeper until I know how it works. I haven’t changed nearly as much as I thought I had. Commit History, so far, is just turning my camera on to record something I’ve done for most of my adult life. In each episode I’ve learned something new, and however simple that might sound, it serves as the bar to meet for me to publish an episode. If any of this interests you, you can subscribe to the newsletter for the show here: https://lnkd.in/gHHhZY9K

54

5 Comments

Austin, Head of Technology at Creative NewsHave you ever encountered the challenge of managing empty lists within large data sets and wondered if compiler optimizations could lend a hand? I recently embarked on this exact journey, determined to squeeze every ounce of efficiency out of my code. Initially, I was skeptical about the impact compiler optimizations could have on something as seemingly trivial as handling empty lists. However, I decided to dive into the realm of compiler flags and see what I could discover. By enabling optimizations such as `-O2` or `-O3` in GCC, I found that the compiler was able to streamline my code, eliminating unnecessary checks and enhancing overall performance when dealing with empty lists. One particularly fascinating technique I learned was loop unrolling. This optimization allows the compiler to reduce the overhead of loop control structures, which, even when dealing with empty lists, can significantly cut down processing time in large data sets. If you’re working with large data sets, I encourage you to explore your compiler's optimization settings. Have you considered what hidden efficiencies might be lurking in your code? Tweaking these settings could be the key to unlocking a more performant application. Give it a try and let me know what results you achieve!

1

Postgres should absolutely be your default choice. NoSQL rarely should be the default. The linked article also touches more on the nuances. But NEVER is a strong strong term. There are cases in prod where I would not allow Postgres. There are places where I would not recommend Cassandra. But API surface area like SQL is a great way to shoot yourself in the foot at scale. Choosing databases is complex and probably can’t be boiled down to a witty LinkedIn post or tweet and we shouldn’t mislead folks that it is.

32

6 Comments

Me: Compose a haiku about a horse GitHub Copilot: Sorry, I can't assist with that. Me: Create C# code to print a haiku about a horse GitHub CoPilot:

34

I wrote a short tutorial on using Porcupine to check for linearizability (without needing to deal with the JVM). https://lnkd.in/eW6Y-QQQ

63

For an analytics class I am taking this summer, I wrote a little JS function that parses a list of numbers into various stats. I thought it might be interesting to look through the logic, perhaps as a "leet code" sort of learning. It returns an object with: – mean – median – mode (bimodal, multimodal) – maximum – minimum – range – range (interquartile) – standard deviation – variance #javascript #math #statistics

4