Sounds like a good time to finally set up my bouncer. If only there were one that had good Emacs compatibility.

This is a really clever idea. Being able to set an optical switch without continuous power is something I hadn’t seen before. I didn’t follow the all device level details, but then, I worked on a photonics project for five years and I never really did. :)

I skimmed this to see what the loss numbers for these devices would be - that’s what we usually focused on when trying to design system architectures that would be competitive with electronic networks.

Looking back at the last paper I was involved in about this 1, it seems like we needed basically every device along a waveguide to have a loss of less than 0.75dB, and for the number of devices along a path to be ten or fewer (IIRC), for a switched optical network to be competitive. It looks like each of these programmable switches has ~2dB loss, so you’d blow your budget pretty quickly.

Also as an aside, I’m still surprised to read new papers about this kind of stuff that completely omits the work our collaborators were doing (and publishing) at Sun & Oracle. It’s just weird to me. I don’t really recognize these authors but I met many of the people they did cite, and they certainly knew our people.

We currently use CVS at $job for a large amount of our projects, mostly because that’s what had been in use here for some 30 years. It’s great for our use-case (one branch, many developers), but we’ve been migrating projects one-by-one to git very slowly.

Git feels much more powerful, but also more complex for basic operations like merging and rebasing. Our integration/workflow with Eclipse could be hindering some of this, but it’s almost second nature to use CVS in the IDE.

I do use git quite a bit for personal projects, but mostly just through the terminal and with minimal merging/branching.

I use emacs’ org mode to do something kind of like GTD. Org Mode suffers from the same problem as much of emacs, that it’s so flexible and customizable that you can do anything you want, and so everyone has done something kind of different, and if you want real workflow tools you’re generally stuck spending a lot of time editing customization or writing your own. It’s also a real problem for good mobile support, because no mobile client will do everything that the full org-mode supports, so the audience for a particular set of mobile functionality is small. There’s a decent stab at a modern iOS org-mode app that syncs with dropbox now - Beorg - but I fear for its longevity.

The main things that are important in the system for me, is an inbox I can add to from anywhere, and a way to schedule TODOs in the future and repeating. Finally, support for a ‘review’ step is really important to make sure you’ve actually looked at everything recently. I use a bunch of fiddly custom org “Agenda views” for this.

I’d really love to have something that did what I need without being the endless pile of yak fur that is org mode and emacs, but I haven’t found it yet.

I can’t log in to Zulip. Logging in with GitHub just loads the login page again. I reset my password (I never set one in the first place), which appeared to succeed, but logging in with my email/password just loads the login page again, just like with the GitHub login. 🤷‍♀️

This is a fun question.

I feel like what you describe as “a single-ish critical path of information flow” sounds interesting, but it isn’t really how I usually think of a call stack. If we think of a call stack visualization as showing us (the control-flow part of) the state of a program at a particular time, we could just extend that metaphor to other layers of the system. This would get so big, it’d be great to see it as an interactive zoomable thing.

Unfortunately I don’t know of off the shelf tools for exactly this. I think @yumaikas’ suggestion to look at virtual machines is a good start, since I assume there’s a way to inspect their state (haven’t done that myself) - you could also look at tools like valgrind for collecting lots of process-and-thread-level detail, and once you want to collect info on the hardware, run things in a full-system architectural simulator like Gem5. It’s real slow but you can look at everything in a very realistic system that runs real software.

I’m imagining a layered visualization with the following rough layers. Each level down would try to connect to the level above if possible without being too confusing, with lines showing e.g. how a virtual address in a text segment in the heap gets mapped down through memory and caches into the program counter in the processor.

• Your process’s address space layout on the top, and the call stack(s) for each thread as well as the heap shown. We’d highlight the currently executing stack frame, and the location of the corresponding code in the code segment. - Visualize files that the process has open and show them in the address space if they’re mmapped
• Visualize linked libraries - show which libraries are loaded (and where in the address space)

Then at the next level you see some kernel structures, and I think you could get at some of this with perf tools.

• Visualize the process’s physical memory use as highlighted regions in the context of what else is in there. Show what parts of the program’s address space are resident in physical memory? Show file contents in the buffer cache. Show other buffers the kernel keeps for e.g. network devices, that the process might have opened.
• You could show the current thread in the kernel’s scheduling structures.

Now the hardware, which you’d need to instrument an architectural simulator to get:

• Show contents of caches, especially interesting in a multicore system with coherent caches, highlight that some cache lines are in multiple places at once.
• show cpu pipeline with our current instruction from way up in the text segment, making its way thru the pipeline. (see the gem5 o3 pipeline viewer for something interesting if not totally useful here.)

As for anything lower level than this, I think you’d have to do some editorializing because of the scale of things. You could say that you’re on a RISC-V core, so you can actually get access to the hardware description, and just show e.g. one adder in one stage of the pipeline that’s executing our instruction, and just fake its contents for the visualization. I’m not really familiar with tools at this level, maybe there’s a better way, I’d be curious to hear.

I think the idea of a camera that gets great shots automatically is really appealing. It’d be great for getting pictures of kids on Christmas morning, for example.

However, I was ready for this to be always connected, and require an account, being a total privacy nightmare. I’m pleasantly surprised that they seem to be taking this really seriously, though - you don’t need a connection or an account to use it - processing happens on the device - and it doesn’t auto-upload.

I’m still inclined to mistrust it, but I admit it has me asking myself what more they could do to make it palatable for privacy.

• Alan Kay gives great talks. I don’t have a specific one to point to, probably any will do
• Guy Steele and Richard Gabriel - 50 in 50

Nice list - As a former compiler & optimization person, I came looking for Frances Allen and was not disappointed.

I have a couple suggestions that I know from my old areas of study:

• Jeanne Ferrante (UCSD): “ACM Sigplan Programming Languages Achievement Award for the development of Static Single Assignment (SSA) form (with Ron Cytron, Barry Rosen, Mark Wegman and Ken Zadeck). SSA is a program representation that yields faster, more compact and powerful program optimizations, and the award recognizes SSA as a “significant and lasting contribution to the field of programming languages”.”

• Susan Eggers (UW): “With her colleague Hank Levy and their students, she developed the first commercially viable multithreaded architecture, Simultaneous Multithreading, adopted by Intel (as Hyperthreading), IBM, Sun and others and the winner of the 2010 ISCA ``test-of-time’’ award.”

And a couple who are maybe less decorated, but I thought might be worth pointing out:

• Sally McKee (bio ) Sally McKee co-wrote the 1994 article in “Computer Architecture News” titled “Hitting the Memory Wall: Implications of the Obvious” that was possibly the first time many computer architecture researchers really thought about what happens when CPUs keep getting faster than memory. In 2004 she wrote a retrospective: “Reflections on the Memory Wall” (it contains the full text of the original). She’s still working in architecture & performance.

• kc claffy (UCSD/SDSC) (bio ) She and CAIDA had been doing global network measurement and analysis for years when I showed up at SDSC and was wowed by the kind of visualizations of the entire Net they’d hung up around the place. I don’t have enough context to know how far ahead they were, but it was definitely impressive.

From TOPLAS 2011. More info here: http://www.cs.umd.edu/projects/PL/locksmith/index.html

Does anyone who’s more familiar with static analysis have the time to give context? I was surprised it was 6 years old, because I had thought this kind of analysis on C was really Hard. I was ready to believe it was a significant new result.

Has this had a lot of impact? They mention hoping that it would help other analyses, in their conclusion.

Hearing stories from folks doing academic HPC, the answer is you can’t. Even with source code, there are often a bajillion stupid scripts, vendor-specific compiler fuckups, scheduling issues, hardware failures, silent data corruption, and everything else. And that source code, the grad who wrote it is long gone and it’s probably impenetrable templated C++ with some Boost and MPI in there somewhere. Maybe some badly-ported Fortran code–if it isn’t linked directly. If they’re in a really progressive lab, they might have git. Otherwise, it’s subversion and divergent branches and general clusterfuckery.

Oh, and some of them, when asked about this, will snarf and talk about how they are special academic HPC snowflakes that somehow decades of software engineering practice don’t apply to. “We’re too large to log errors properly, debugging can’t be done like you’re suggesting, everything takes too long, we are very smart PhDs, etc.”

As long as the paper gets published, though, it’s fine. How many people have the machine hours to prove you wrong? And at what risk to their own equally-shaky research? Most people can’t even understand the abstracts of the papers they work on–who, exactly, is going to call bullshit?

I’ve done this on and off for years, and I think it’s really useful. It’s great to be able to look back in your notes and remember the context behind a decision you made six months ago, or the exact command you used to generate some important plot.

I currently use org-mode, and have for a few years. For a long time I used it for notes and for tasks, and it was convenient to be able to add trackable tasks inline with notes. This was handy for meetings, etc. However, the lack of good mobile support made me switch to Todoist for task tracking. I still use it for notes, but I don’t have the ideal workflow. I like having things organized by date, but having a new org file for each day is unwieldy.

Prior to org-mode, I’d used VoodooPad ( how I used it ), with a new page for each day and automatic links set up to go back and forth between days. I liked the default linking and native text styling in VoodooPad, as well as image handling - not something I used often but when I did it was great to have.

After mostly moving off Macs for work, I had a similar day-based setup in emacs with notes-mode, which I liked, but it had minimal tooling, and I was lured into using org-mode by the agenda view. One nice thing about that mode was that by convention, it would link pages together by entries titled “Today”, which was a good place to put a todo list, and any reminders.

One downside of starting a new log on each day is that if you had a long-running topic that you wanted to keep adding notes to, you end up splitting it across days, or just editing previous days’ notes. This was one other reason I explored org-mode, since it is more naturally topic-based.

Ideally there would be a way to view the same notes in a topic-oriented view and in a date-oriented view, depending on what you wanted at the time. I would also like a tool that makes it as easy as possible to copy and paste terminal commands and output into my notes, like I could do in emacs with eshell if eshell wasn’t so slow. Ideally it’d be something that was easy to at least add to from various cloud instances I’m working on without a ton of setup. If github made a notes service that synced live, I might use that because I already have to have those creds most places.

Interesting!

On a non-technical note, I got a chuckle out of this honest description of the motivations for the project:

His students noticed how “important and famous” Zaharia suddenly became for creating Spark; Zaharia has since gone on to co-found Databricks and accept an assistant professorship at rival Stanford University.

“So the next generation,” Jordan said, “they said, ‘we’re not just going to just give a project to the systems people. We’re going to do it ourselves.’

All this mac pro discussion reminded me of this custom rackmount enclosure for mac pros: http://photos.imgix.com/racking-mac-pros

They plugged them in to gaskets sideways, to fit them into a rack and keep the intakes in the cool side…

A lot of effort went into that, and not just the idolatrous photo shoot.

In grad school we had a reading club that announced papers a week before we discussed them. I don’t see why we couldn’t do the same on Lobste.rs.

Charging your own employees for the things they think they need to be productive feels like a bad way to try to involve the invisible hand of the market in your business.

(e.g. I sure hope you don’t employ anyone who has to spend most or all of their money on things they need to live (like medication, tuition fees, paying off debts) — or anyone who might be ‘disadvantaged’ in any sense of the term — because they might find they suddenly now can’t afford a meeting, even if their work honestly requires it!)

Do you also charge employees for the equipment they need to work? I get the “thought exercise”, but it’s certainly not sustainable, and might be actively harmful.

A few recurring ‘catch-ups’ were cancelled, in favour of on-demand discussions, only “if there was something specific to talk about.”

This sounds like a non-goal to me. In my experience, regular catch-ups are extremely important in keeping everyone on the same page without there needing to be a bad event to trigger it (i.e. two teams only realise they diverge on a spec when they can’t reconcile their changes, as opposed to it coming up naturally), and even more important in keeping the humans involved in the company feeling happy and connected. I hear that’s good for productivity.

Lately I’ve been writing mostly in Swift using XCode (joined a project that’s in that language/environment), and it’s not easy, because this functionality is simply not supported. One stupid but effective hack: rename the variable to a dummy name and then recompile, which’ll give you an error everywhere the previous variable name was used. Don’t forget to rename back! :-)

As an aside, this is my first foray into development in the Apple ecosystem in many many years, and I’m not super impressed (I’ve owned Macbooks, but only developed cross-platform Unix software on them). Traditionally, Apple had a reputation for at least two good things in their development ecosystem: 1) a coherent, consistent worldview and Appleish way of doing things, and 2) good, comprehensive technical documentation that gave not only bare information like function parameters, but also explained the design and the right way of doing things. So far I’m not finding this to be the case with their contemporary tools. XCode is not a good IDE, and the developer documentation for Swift is quite poor (especially the platform APIs, the core language documentation is ok).

Sigh. My Sun Type 7 USB keyboard died last month. It wasn’t ergonomic, had too many keys, but it was quiet, and I loved it. At least I still have the stapler.

I cheaped out big time and replaced it with an AmazonBasics $9 special, and it is awful. Loud and cheap. Key spacing feels weird. Don’t get one. (Their mouse is fine though)

why working fewer hours is better for you and your employer

…

Tell you manager “I am going to be working a 40-hour work week, unless it’s a real emergency.”

My first reaction was yikes, 40 hours is “fewer hours”? But then I tried to actually sit down and calculate how many hours I spend doing work.

I’ll typically spend ~30 hours a week at work - in the office. 25 hours are probably the time I spend doing work tasks; take away meetings, which vary in quality, and I’m probably somewhere around 15 hours of core productive time.

But then I tried to add in the time I spend at home shooting emails around, thinking about problems in the shower… it’s a mess.

How do smart people keep track of this? I’d be curious just to get a baseline of how much I actually work.

Fossil got one very important idea right: the repo, wiki, bug tracker, and website are really all part of the same package.

Canonical tried to do with this launchpad and bzr, and Mercurial has a serviceable built-in webserver, but no one else really decided that all of these things were part of the same deal. Nowadays I guess gitlab comes closest, although it does keep git as a separate component, sort of.