Education and “Internet Time” June 30, 2015
Posted by gordonwatts in Teaching, university.add a comment
I saw this link on techcrunch go by discussing the state of venture capital in the education sector. There is a general feeling, at least in the article, that when dealing with universities that things are not moving at internet speed:
“The challenge is, in general, education is a pretty slow to move category, particularly if you’re trying to sell into schools and universities … In many cases they don’t seem to show the sense of urgency that the corporate world does.” says Steve Murray, a partner with Softbank Capital, and investor in the education technology company, EdCast.
I had to laugh a bit. Duh. MOOC’s are a classic example. Massively Open Online Courses – a way to educate large numbers of people with a very small staff. The article refers to the problems with this, actually:
The first generation of massively open online courses have had (well-documented) problems with user retention.
So why have universities been so slow to just jump into the latest and greatest education technology? Can you imagine sending your kid to get a degree from the University of Washington, where they are trying out some new way of education that, frankly, fails on university scale? We are a publically funded university. We’d be shut! The press, rightly, would eat us alive. No institution is going to jump before they look and move their core business over to something that hasn’t been proven.
Another way to look at this, perhaps, is that each University has a brand to maintain. Ok, I’m not a business person here, so I probably am not using the word in quite the right way. None the less. My department at the University of Washington, the Physics Department, is constantly looking at the undergraduate curricula. We are, in some sense, driven by the question “What does it mean to have a degree from the University of Washington Physics Department?” or “What physics should they know?” or another flavor: “They should be able to explain and calculate X by the time they are awarded the degree.” There is a committee in the department that is responsible for adjusting the courses and material covered, and they are constantly proposing changes.
So far only certain technological solutions have an obvious “value proposition.” For example, the online homework websites. This enables students to practice problems without having to spend a huge amount of money on people who will do the grading of the exams. Learning Management Systems, like Canvas, allows us to quickly setup a website for the course that includes just about everything we need as teachers, saving us bunch of time.
Those examples make teaching cheaper and more efficient. But that isn’t always the case. Research (yes, research!!!) has shown that students learn better when they are actively working on a problem (in groups of peers is even more powerful) – so we can flip the class room: have them watch lectures on video and during traditional lecture time work in groups. To do it right, you need to redesign the room… which costs $$… And the professor now has to spend extra time recording the lectures. So there is innovation – and it is helping students learn better.
I think most of us in education will happily admit to the fact that there are inefficiencies in the education system – but really big ones? The problem with the idea that there are really big inefficiencies is that no one has really shown how to educate people on the scale of a University in a dramatically cheaper way. As soon as that happens the inefficiencies will become obvious along with the approach to “fix” them. There are things we need to focus on doing better, and there are places that seem like they are big inefficiencies… and MOOC’s will have a second generation to address their problems. And all of us will watch the evolution, and some professors will work with the companies to improve their products… but it isn’t going to happen overnight, and it isn’t obvious to me that it will happen at all, at least not for the bulk of students.
Education is labor intensive. In order to learn the student has to put in serious time. And as long this remains the case, we will be grappling with costs.
Trends in Triggering: Offline to online June 5, 2015
Posted by gordonwatts in ATLAS, LHC, Trigger.2 comments
The recent LHCC open meeting is a great place to look to see the current state of the Large Hadron Collider’s physics program. While watching the talks I had one of those moments. You know – where suddenly you realize something that you’d seen here and there isn’t just something you’d seen here and there, but that it is a trend. It was the LHCb talk that drove it home for me.
There are many reasons this is desirable, which I’ll get to in a second. but the fact that everyone is starting to do it is because it is possible. Moore’s law is at the root of this, along with the fact that we take software more seriously than we used to.
First, some context. Software in the trigger lives in a rather harsh environment. Take the LHC. Every 25 ns a new collision occurs. The trigger must decide if that collision is interesting enough to keep, or not. Interesting, of course, means cool physics like a collision that might contain a Higgs or perhaps some new exotic particle. We can only afford to save about 1000 events per second. Afford, by the way, is the right word here: each collision we wish to save must be written to disk and tape, and must be processed multiple times, spending CPU cycles. It turns out the cost of CPU cycles is the driver here.
Even with modern processors 25 ns isn’t a lot of time. As a result we tend to divide our trigger into levels. Traditionally the first level is hardware – fast and simple – and can make a decision in the first 25 ns. A second level is often a combination of specialized hardware and standard PC’s. It can take a little longer to make the decision. And the third level is usually a farm of commodity PC’s (think GRID or cloud computing). Each level gets to take a longer amount of time and make more careful calculations to make its decision. Already Moore’s law has basically eliminated Level 2. At the Tevatron DZERO had a hardward/PC Level 2; ATL:AS had a PC-only Level 2 the 2011-2012 run of ATLAS, and now even that is gone in the run that just started.
Traditionally the software that ran in the 3rd level trigger (often called a High Level Trigger, or HLT for short) were carefully optimized and custom designed algorithms. Often only a select part of the collaboration wrote these, and there were lots of coding rules involved to make sure extra CPU cycles (time) weren’t wasted. CPU is of utmost importance here, and every additional physics feature must be balanced against the CPU cost. It will find charged particle tracks, but perhaps only ones that can be quickly found (e.g. obvious ones). The ones that take a little more work – they get skipped in the trigger because it will take too much time!
Offline, on the other hand, was a different story. Offline refers to reconstruction code – this is code that runs after the data is recorded to tape. It can take its time – it can carefully reconstruct the data, looking for charged particle tracks anywhere in the detector, applying the latest calibrations, etc. This code is written with physics performance in mind, and traditionally, CPU and memory performance have been secondary (if that). Generally the best algorithms run here – if a charged particle track can be found by an algorithm, this is where that algorithm will reside. Who cares if it takes 5 seconds?
Traditionally, these two code bases have been exactly that: two code bases. But this does cause some physics problems. For example, you can have a situation where your offline code will find an object that your trigger code does not, or vice versa. And thus when it comes time to understand how much physics you’ve actually written to tape – a crucial step in measuring a particle like the Higgs, or searching for something new – the additional complication can be… painful (I speak from experience!).
Over time we’ve gotten much better at writing software. We now track performance in a way we never have before: physics, CPU, and memory are all measured on releases built every night. With modern tools we’ve discovered that… holy cow!… applying well known software practices means we can have our physics performance and CPU and memory performance too! And in the few places that just isn’t possible, there are usually easy knobs we can turn to reduce the CPU requirements. And even if we have to make a small CPU sacrifice, Moore’s law helps out and takes up the slack.
In preparation for Run 2 at the LHC ATLAS went through a major software re-design. One big effort was to more as many of the offline algorithms into the trigger as possible. This was a big job – the internal data structures had to be unified, offline algorithms’ CPU performance was examined in a way it had never been before. In the end ATLAS will have less software to maintain, and it will have (I hope) more understandable reconstruction performance when it comes to doing physics.
LHCb is doing the same thing. I’ve seen discussions about new experiments running offline and writing only that out. Air shower arrays searching for large cosmic-ray showers often do quite a bit of final processing in real-time. All of this made me think these were not isolated occurrences. I don’t think anyone has labeled this a trend yet, but I’m ready to.
By the way, this does not mean offline code and algorithms will disappear. There will always be versions of the algorithm that will use huge amounts of CPU power to get the last 10% of performance. The offline code is not run for several days after the data is taken in order to make sure the latest and greatest calibration data has been distributed. This calibration data is much more fine grained (and recent) than what is available to the trigger. Though as Moore’s law and our ability to better engineer the software improves, perhaps even this will disappear over time.
Life as a Physicist 