Can‘t recommend the fast.ai course by Jeremy Howard highly enough, it walks you through building your own deep learning stack from scratch. What I really appreciate about it is that it demystifies a lot of jargon to what really are quite simple ideas at their core (e.g. „rectified linear unit“ sounding scary even though its literally only a line with a floor).
The 2022 edition isn’t so much about LLMs as about image generation with stable diffusion, but the underlying techniques are still foundational enough to be generally useful. YMMV, but for me building things from scratch, even if results don‘t reach SOTA, is the single most effective way to learn what‘s really going on.
If you enjoyed Permutation City, you‘d probably also like „The Metamorphosis of Prime Intellect“ by Roger Williams!
It explores a similar premise of a post-singularity future (though the mechanism is superintelligence rather than cellular automata/mind uploading), but rather than imagining exactly how we‘d get there, it tries to imagine what human flourishing would look like in a world of perfect abundance!
This is cool, basically the first 3D codebase visualization I've seen that doesn't immediately give me a headache, so good job! :)
Always interesting to see different ways of visualising the same thing. A while ago my friend and I also made a codebase visualisation tool ([https://www.codeatlas.dev/gallery](https://www.codeatlas.dev...), but instead of taking the graph route, we opted for Voronoi treemaps in 2D! It's a tradeoff between form and function for sure, modelling code as a DAG is definitely more powerful for static analysis. However, in most graph-based visualizations (this, gource) I just find myself getting lost super quickly, because the shapes are just not very recognisable.
Really impressed by how polished this already is, nice docs, on-the-fly rendering, congrats!
If I ever find time to work on codebase visualisation again, I might have to steal the idea of codebase entropy to better layout which files to place close to which others!
My friend and I made a codebase visualisation tool (https://www.codeatlas.dev/gallery) that's based on Voronoi treemaps, maybe of interest as an illustration of the aesthetics with a non-rectangular layout!
We've opted for zooming through double-clicks as the main method of navigating the map, because in deep codebases, the individual cells quickly get too small to accurately target with the cursor as shown in the key-path label approach!
If you find this type of codebase visualisation useful, you might want to checkout codeatlas.dev and its Github Action (https://github.com/codeatlasHQ/codebase-visualizer-action). It doesn't animate the repo over time like gource (yet), but instead aims to give a beautiful interactive visual snapshot of a repo at a particular point in time. It also lets you zoom in on specific aspects like recent commit activity, programming language and hopefully in the future test coverage.
If you think this is useful, you might also like codeatlas.dev and its Github Action (https://github.com/codeatlasHQ/codebase-visualizer-action). It currently does not support per-contributor activity, but we put a lot of effort into making the diagrams beautiful to look at and the basic approach of using treemaps for visualisation seems very similar. In fact, could be cool to collaborate on this, DM me if interested!
Takes your git repo and generates a beautiful visual representation of the code. Sort of an alternative navigation tool (in addition to IDEs) for large codebases. Can also run it as part of CI with our Github Action (https://github.com/codeatlasHQ/codebase-visualizer-action).
We made this because grokking complex software projects is really difficult and we've found that a visual overview of what's in a codebase can be quite helpful to get started.
Currently making -10$/year to pay for the domain :D We slowed down active development after our initial attempts at dissemination didn't really go anywhere (bragging about side projects on the internet, ugh), but I'm still really keen on getting some feedback on whether this is actually useful to anyone else!
Note: The site works somewhat on mobile, but is much better on desktop!
It takes your git repo and generates a beautiful visual representation of the actual code that's in it. Sort of an alternative navigation tool (in addition to IDEs) for large codebases. You can run codeatlas as part of your CI with our Github Action (https://github.com/codeatlasHQ/codebase-visualizer-action).
We made this because grokking complex software projects is really difficult and we've found that a visual overview of what's in a codebase can be quite helpful to get started.
We slowed down active development after our initial attempts at dissemination didn't really go anywhere (bragging about side projects on the internet, ugh), but would still love feedback on whether this is possibly useful to anyone else!
Note: The site works somewhat on mobile, but is much better on desktop!
- Our initial Show HN post: https://news.ycombinator.com/item?id=30430165. The previous post was only showing our static gallery - we've since turned this into a GitHub Action that can visualize any repo as part of CI, so thought a repost was warranted
Hmm - at some point we'll have to think about how fund further development, but the current plan for the github action is for it to be open-source (under a BSL-like license) and free to use!
Huh, I hadn't thought about it that way - you're right, infrequent changes could indeed be a good proxy for stability! (or for "dead-and-forgotten" :D)
Complexity is an interesting measure too - I'm currently not sure how we'd model this, but this could definitely help codeowners understand which parts of their codebase is currently difficult for people to wrap their heads around. Or whether there's any complex parts that there's only a single contributor to, without whom the project would be left with a serious knowledge gap.
Once this can run as part of a CI pipeline and thus lives directly in the repo, I'd also love to add an overlay with the output of the testsuite to see which parts of the codebase aren't covered by tests! Or the output of a profiler, to see which functions are actually called the most.
I've already mentioned this on the other thread (https://news.ycombinator.com/item?id=31569646), but my friend and I have been working on https://www.codeatlas.dev as a sideproject - it's a tool for creating pretty (2D!) visualisations of codebases, while providing additional insights via overlays (e.g. commit density, programming language or other results from static analysis like dead code/test coverage/etc.). For example here's the Kubernetes codebase visualised using codeatlas: https://www.codeatlas.dev/repo/kubernetes/kubernetes
At the moment, codeatlas is just the static gallery, but we're only a few weekends away from releasing a Github action that deploys this diagram on github pages for your own repos - if you're interested, feel free to watch this repo: https://github.com/codeatlasHQ/codebase-visualizer-action
OP, how close is this to what you had in mind in your question?
My friend and I have been working on https://www.codeatlas.dev in our spare time, which is a tool that creates pretty (2D!) visualisations of codebases, while providing additional insights via overlays (e.g. commit density, programming language). For example here's the Kubernetes codebase visualised using codeatlas: https://www.codeatlas.dev/repo/kubernetes/kubernetes.
At the moment, codeatlas is only a static gallery, but we're currently about 1-2 weekends away from releasing a Github action that deploys this diagram on github pages for your own repos - if you're interested, feel free to watch this repo: https://github.com/codeatlasHQ/codebase-visualizer-action
Hi HN - we've been quietly working on visualising codebases for a while now and thought it was a good time to finally get some feedback!
The purpose of Codeatlas is to speed up onboarding for complex codebases and provide an overview map to hang onto while learning which parts of the code do what. Our visualisations are based on the byte size of all the files in a repository and come with overlays for commit density and programming language usage. We've put together a gallery of 50+ interesting open-source projects to explore over at https://codeatlas.dev!
We're not quite ready yet to let users visualise codebases on demand, but thought it would be a good time to get some feedback on whether people find this project useful. We have loads of other ideas for how to improve this further as an online platform, i.e. on-demand visualisation, more overlays (e.g. dead code, CI fails, contributors), smartly showing READMEs, annotating the graphs as an 'interactive tour' through the codebase, .. !
Find our current roadmap here: https://trello.com/b/jg1kn5c2/codeatlas-roadmap
If you have other ideas to make this more useful, we'd love to hear from you at [email protected]! Also, if you'd like to be notified when we ship any of these big features you can sign up to our mailing list at https://codeatlas.dev/about. We'll be respectful of your inboxes and only send out updates when there's actually something new to check out.
Another (completely different) direction we'd love to try out (if there's enough interest) would be to have our codebase visualisations printed onto T-Shirts to use as company swag, thoughtful gifts for open-source contributors or just because they're pretty. If that sounds like something you'd be interested in, please let us know on this Google Form: https://docs.google.com/forms/d/e/1FAIpQLScl5CR6FkVhJMAVbDlh...
To be fair though, it's quite clear that AGI is the intended overarching theme of the podcast. I'd argue that regardless of how any individual interview goes, Lex is creating incredible value by getting all of these top-notch thinkers to join a shared long-term conversation on what this technology means to us all.
The 2022 edition isn’t so much about LLMs as about image generation with stable diffusion, but the underlying techniques are still foundational enough to be generally useful. YMMV, but for me building things from scratch, even if results don‘t reach SOTA, is the single most effective way to learn what‘s really going on.