Austin Henley

I just wrote up my experiences of using it for a week: https://austinhenley.com/blog/copilotworkspace.html TL;DR: Copilot Workspace is a great concept. But the UX and framing is entirely wrong and sets the wrong expectation for users. The current prototype is very slow (5+ minutes for one-line code changes) and the generated code is often buggy or has nothing to do with the specification. It doesn’t help me understand the code. The generated plan is usually good. ChatGPT does a much better job in my head-to-head comparisons (assuming I already know exactly what code is relevant). I'm still optimistic of where it can go from here. I recommend everyone sign up to try it and give the team feedback.

Everyone learns differently, so find the way you learn best. If you learn best by doing, you should do side projects, and they don't need to be novel ideas. There are tons of lists of project ideas (e.g. https://austinhenley.com/blog/challengingprojects.html). Also, improvement can come at an accelerated rate if you have a short feedback loop e.g. a mentor or another person to work on a project with you, as opposed to going solo. It also helps with motivation.

Hi Austin! Was just checking your blog and the vowels detection post (< https://austinhenley.com/blog/vowels.html>). What exactly do you mean by “use SIMD directly without calling out to another language”? In some way Assembly will probably anyways be another language… but that’s a technicality. I guess the spectrum of SIMD-related work in relation to Python is quite broad. There are projects like PeachPy, to help one write x86 Asm in Python, new Python’esque languages like Mojo, or SIMD libraries with thin CPython bindings. Do you mean one of those? PS: I’m in the last camp. And in case you are focused on ASCII, for vowel search, have you tried StringZilla’s `find_first_of` (< https://github.com/ashvardanian/StringZilla/blob/960967d78c7facf6de2de… I think it should perform well ;)

Which one and in which direction did you rethink? Your comment made me curious so I looked at his posts and he has a one about leaving academia because he wasn't happy in 2022, and a more recent one about rejoining it some months ago. https://austinhenley.com/blog/leavingacademia.html https://austinhenley.com/blog/rejoiningacademia.html

I really think you'd like these two project pages, they were posted to HN some time ago but the original links have been slain by bitrot. https://austinhenley.com/blog/challengingprojects.html https://austinhenley.com/blog/morechallengingprojects.html

This might be shocking to some, but when a researcher receiver a federal grant (for example), the university takes a significant cut which they refer to as Facilities and Administrative (F&A) costs [1]. The F&A covers the so-called "indirect" costs of conducting research on university facilities: buildings, utilities, admin and accounting, support staff for compliance with federal regulations, etc. Each university has its own F&A rate, which can be as much as 60% of received federal funds [2]. This rate has historically trended upward. An example of funds allocation for a typical small NSF grant: https://austinhenley.com/blog/grantbudget.html [1] https://files.eric.ed.gov/fulltext/ED517263.pdf [2] https://financeandbusiness.ucdavis.edu/finance/costing-policy-analysis…

Yeah I think that would be useful and we'll get there! For studies someone else pointed out https://austinhenley.com/pubs/Henley2014CHI_Patchworks.pdf

Thanks! > did you measure the correlation between CodeAid use and test scores? Unfortunately, we couldn't measure such correlations due to many external factors that can impact students' performance on test scores. However, our previous research specifically compared students learning python coding for the first time with and without LLM code generators. Austin and I wrote a summary on it here: https://austinhenley.com/blog/learningwithai.html We found that students who performed higher on our Scratch programming pre-tests (before starting the Python lessons), performed significantly better if they had access to the code generator. However, the system that we used in that study was very different, it showed the exact code solution to the students' query. Here with CodeAid we were trying to avoid producing direct code solutions!

Every word you wrote is true. It's all still true if you replace "DSL" with any project and "Boring Old Language" with the competitor. This is the stopping at 90% problem somebody just posted a link to in another thread. edit: https://austinhenley.com/blog/90percent.html

All progress bars lie https://austinhenley.com/blog/fixprogressbars.html It's a challenging problem, because either attempts at a solution (being direct, or being indirect) causes a worse user experience due to expectations of linear progress. For example proposed solution 1 in the article would have you create some sort of animation or additional progress bar to let people know if something is actually stalled/dropped vs something just taking more time, you would still be lying to them, but it's for the benefit of user experience.

This caught my eye, since I'm doing the Teeny Tiny Compiler tutorial [0] (transpiles a tiny BASIC-inspired language to C). So, I thought I'd take a look and see how a modern BASIC compiler does it! Alas! This appears to be proprietary. (There is a GitHub but only for bug tracking.) [0] https://austinhenley.com/blog/teenytinycompiler1.html

The way I understood [1] is that even a trivial app (such as a clipboard URL logger) will take longer than 2 hours once you start adding the polish. I don't think that can be refuted by writing a 5-minute non-polished version of the app. [1] https://austinhenley.com/blog/thisprojectwillonlytake.html

They blogged about it here: https://austinhenley.com/blog/leavingacademia.html

Browsing the author's site, I notice they have a post about Information Foraging Theory, a framework that has been very helpful for me in my technical writing career! https://austinhenley.com/blog/informationforaging.html

EDIT: Paste this hacky snippet into your browser's console to save all of the links into your clipboard: (() => { let result = [...document.querySelectorAll('td a')] .map((link) => link && !link.href.includes('ycombinator') && !link.href.includes('javascript:void') ? link.href : '' ) .filter(Boolean); result = [...new Set(result)]; result.sort(); copy(result.join('\n\n')); })(); Just to help, here's a compiled-list of all of the links shared here so…

Here are some great but lesser known blogs: - Brian Robert Callahan https://briancallahan.net/blog - Austin Z. Henley https://austinhenley.com/blog.html - Robert Nystrom http://journal.stuffwithstuff.com - poor.dev https://poor.dev/blog - Simon Willison’s Weblog https://simonwillison.net

'Challenging projects every programmer should try' - first example is a text editor with some pointers to some data structures to consider, some design patterns to use, and a few links to other resources. https://austinhenley.com/blog/challengingprojects.html

A bit of a plug, but for my senior project, my team is working bringing Patchworks (slide 80) to Atom. It's currently not open source (but will be after completion of the project). We are working with an author of the original paper. http://austinhenley.com/pubs/Henley2014VLHCC_Patchworks.pdf

All mainstream version control systems (e.g. cvs, perforce, git) are designed for text but otherwise language agnostic. They are unsuited to visual languages which don't have a textual equivalent. Existing visual languages might not have good version control, but you certainly can provide it. See http://austinhenley.com/pubs/Henley2016VLHCC_Yestercode.pdf

You got it! By approximate category and in no particular order: ## MISCELLANEOUS - [Low Tech Magazine](https://solar.lowtechmagazine.com), a solar-powered website showcasing the amazing low-tech things you can do with a little ingenuity, - [Stephen Wolfram's Blog](https://writings.stephenwolfram.com) on math, compsci, and everything else, - [Cool Macrophotography](https://www.barrywebbimages.co.uk/Images/Macro/Slime-Moulds-Myxomycete… for amazing pictures of tiny things (WARNING: Time Sink!), ## COMPUTER SCIENCE - [While-True-Do](https://blog.while-true-do.io) has lots of stuff on Linux administration and self-hosting, - [Backend Banter](https://www.backendbanter.fm) for a great podcast on backend development, - [Two Wrongs](https://two-wrongs.com) for statistics and functional programming, - [Math ∩ Programming](https://www.jeremykun.com/) where math and programming intersect! Written by a Googler... - [Paul Bourke's site](https://paulbourke.net/) where you can get happily lost exploring old pages on every topic CS touches, - [Jason Punyon's blog](https://jasonpunyon.com) for some fun algorithms and things, - [Yossi Kreinin's blog](https://yosefk.com/blog) for C, Python, and plenty of non-technical topics, - [Adrian Sampson's academic blog](https://www.cs.cornell.edu/~asampson/blog) for an academic's perspective, - [Cool polyhedra viewer project](https://georgehart.com/virtual-polyhedra/vp.html) if you like geometry, - [Another academic blog on…

Read good books like Designing Data Intensive Applications and High Performance Browser Networking. Learn how to communicate with folks outside of engineering. i.e. by spending time with peers in product management, customer support, marketing, etc. Do projects that push your understanding: https://austinhenley.com/blog/challengingprojects.html and https://austinhenley.com/blog/morechallengingprojects.html. Join a startup if you haven't worked for a startup. Join a massive corporation if you have only worked for startups. Read more source code of projects and your dependencies. Make contributions to the docs, improve the error messages of projects you use. Write blog posts or just notes to yourself to organize your thoughts and ensure you understand what you think you do. Join companies or teams within your company where you feel challenged to grow, not being complacent. Don't worry about feeling like an idiot. Just a couple of ideas.

http://computationalculture.net/rss https://2019.wattenberger.com/rss https://austinhenley.com/blog/feed.rss https://blog.ouseful.info/feed https://jakelazaroff.com/rss.xml https://joshmpollock.com/feed.xml https://lilianweng.github.io/index.xml https://maggieappleton.com/rss.xml https://runzhe-yang.science/feed.xml https://thereader.mitpress.mit.edu/feed/ https://thesephist.com/index.xml https://topos.site/blog/index.xml https://www.geoffreylitt.com/feed.xml