ben_straub

Nah, I'm just repeating what @bryanveloso said: https://twitter.com/bryanveloso/status/324204710888357888 and https://twitter.com/bryanveloso/status/324214383989383168.

It's Apex Sans: http://vllg.com/Constellation/Apex_Sans

The downside with this approach is that, with active projects, you end up with hundreds of remote branches. They'll never get deleted with `fetch -p`, and if you remove them manually they'll just come back.

Not if I can help it. They're using the project I work on as their git layer: http://libgit2.github.com/

(Libgit2 contributer here.) Currently, SSH support is in-progress in libgit2 (what all of this is built on), so there is no dealing with keys right now. :) Once the API is in place, it should be fairly straightforward for the VS team to deal with keys in a user-friendly way.

I've been using git on Windows for years, and while the need for msys stuff is a little clunky, I've never had any problems using it. In fact, the built-in gui tools (git-gui and gitk) work WAY better on Windows than they do on OSX.

libgit2 will eventually make it possible to make a nice GUI client without shelling out to git itself. GitHub for Mac and GitHub for Windows both use it now, and it's way better than parsing shell output.

Libgit2 contributor here. The SSH transport is actually in progress, so this specific issue will go away fairly soon. I'll agree that the error message could be better, but my gut feeling is that most people will clone from within VS and use the HTTPS transport anyway.

This is very much a pre-version-1.0 UI, but I like the direction they're taking it. Really in touch with what their users want and need.

Nice catch. Fixed!

Rebasing isn't really destructive. Try it: open `gitk --all`, do a rebase -i and squash all the commits together, then switch back to gitk and refresh. You'll see all the old commits still in the database, but the HEAD and master branches point at the new commits. Totally not destructive, but it does take a bit of knowledge to undo the change.

Git maintains what's called a "reflog" to help with this. It's a record of every place that every ref has ever pointed in your repository. Try it: `git reflog master`. You can even see when you did pulls, and what they merged in.

The only truly destructive thing you can do to your git database is `git gc`.

OSX has definite advantages here.

1. The trackpad hardware is great. It's so good that when we were making the Bamboo Touch at Wacom, the Macbook Pro trackpad was the standard we measured ourselves against.

2. True pixel-level scrolling from HID devices. Windows has the concept of "wheel scrolling", but it's only vertical, and lots of apps won't scroll in less than a wheel increment (which is oddly 120 units), so you're stuck with jerky 3-lines-at-a-time scrolling. Oh, and it's vertical-only; there's no system standard for horizontal scrolling.

3. It's never had a software-based rendering and compositing engine for the windowing system. The Windows team is fully committed to backward-compatibility, which means allowing all sorts of wonky GDI-based pixel pushers to work they same way they did in Win95. OSX has been OpenGL-based from the start.

I used to work for Wacom, and there's another reason they're so expensive: volume. Think how much a retina display would cost if, say, Samsung made it in 10k-per-year quantities, and you'll have an idea. Wacom just isn't a big enough fish.

They also have an insanely high threshold for parts quality, but without the volume to keep manufacturers making the same parts, they keep running out. The new Cintiq[1] has one of the nicest displays you'll ever see, but it will likely always be in short supply.

[1] http://www.wacom.com/en/Products/Cintiq/Cintiq24HD.aspx

No, it's more like the IDE is augmenting your brain and fingers. The code comes out readable, but you only have to type a fraction of the characters. It's a code-writing assistant robot.

Also, it makes APIs incredibly discoverable. Not sure what a `IQueryable` provides?

    IQueryable iq = null; iq.

and scroll through the popup. Instant one-line descriptions are available in the tooltips, and you can get full documentation with F1. you've ever experienced this, it's REALLY hard to go back to Emacs. It's incredibly well done.

(edit: formatting)

Made a Pandora station seeded from the artists in all the mixes.

http://www.pandora.com/#!/stations/play/738121268334091862

I was just at a PPA conference (Imaging USA in New Orleans), and every session started with a PPA rep saying "No photography. All slides are protected by copyright." I don't even know where to begin.

Not so shocking, actually. The 5D is a pro camera, and you're expected to pull the RAW data into Lightroom and manually tweak and tune the final product. Its output is optimized for this workflow: minimum processing in-camera, maximum options later.

The iPhone's software, on the other hand, is doing some auto-adjustment before the file hits the SD card. It's optimized for a decent photo without any manual steps.

Also, notice the distortion in the iPhone photo: the buildings "lean" towards each other. The Canon 24-70mm f/2.8 is a _nice_ piece of glass, and is worth every penny of its $1500 asking price.

tl;dr: Take the 5D shot (in RAW, hopefully) and let a pro have a shot at it in Lightroom. That's a fair comparison.

You don't have to rewrite your entire app. In fact, there are probably large parts of it you can reuse. But you can't expect a Win32-style UI to work in Metro, and you can't expect sandboxed apps downloaded from a marketplace to be running as admin and have full access to the registry, either.

Can WPF apps run on Win8? Yes. Are they preferred when the user is running an iPad-like device with no keyboard and fat-finger pointing accuracy? No. How about when the user has a keyboard, mouse, and desktop? Sure. Is Excel usable with fingers? Not really.

This is just like when Apple released OSX 10.5, and all of a sudden all the Carbon apps had to be rewritten. Except not; Microsoft will still let you write Win32 apps and run them on Windows 8, where Apple said "if you want to run on 64-bit OSX, rewrite."

Microsoft is releasing a new OS with a better UI stack and programming model, and preserving the ability to run legacy apps on machines they're compiled for. I wasn't around for the OS9 -> OSX transition, but I'm guessing there was much wailing and gnashing of teeth then, too. How many people wrote public breakup letters with Apple when that happened?

I've been wanting Microsoft to do this for years. The Win32 API is very powerful, but supporting it is a severe constraint; just ask Raymond Chen. I think Apple did the right thing by making a clean break, telling everyone "from now on, things are going to be different, and better."

Microsoft isn't Apple. Their biggest customers aren't end users; they're large corporations with thousands of users, and PC manufacturers. Tempting end users is just marketing to them.

http://www.joelonsoftware.com/articles/CamelsandRubberDuckie...

This is actually the question the product answers. A lot of graphic designers like to start designing on paper, then move to Illustrator or PS for the final work. The classic way to do this is to scan in your sketch and make it a layer, and essentially start over with digital art on top of it.

Inkling lets you split your sketch into multiple layers as you're sketching it. Say you're drawing a character for a game, and the character can be carrying things. You can sketch the two together, with overlapping lines, but keep the character and the carried thing on separate layers. All without having to find the boundaries and snip carefully to separate them in PS.

I worked for Wacom up until 4 months ago, and I was involved in the development of this product. I'm not sure how much I can talk about this without violating NDA, but I'll try.

Normal Wacom tablets use electromagnetic resonance (EMR) to both power the electronics in the pen and to locate it in 3D space. Inkling uses the same technology for pressure sensitivity in the pen tip, but location is performed by a different method, using the base (the part you clip on). It's not nearly as accurate as EMR coupling (the tablets are accurate to less than 1mm), but the ability to record an ink drawing is pretty awesome. No matter how well natural media is simulated, it's never going to be actual real paper and ink.

The largest benefit you can expect to get from compiling 64-bit is the ability to address more memory. Performance is a bad reason, unless you need extra floating-point precision or your problem is highly vectorized, and you just doubled the size of all your pointers, so you'll be getting more cache misses. I'm really interested in how they managed these downsides.

As a father of two, I heart this idea. This takes the budgeting headache away from the manager, and is completely fair.

It implies that every developer is responsible for his/her own workstation maintenance, though, and that might be a risk/pain you don't want.

I think you're straw-manning the premise. He's not talking about the difference between a '10 MBP and an '11 MBP, more like the difference between a mid-to-high-end '08 MBP running Leopard and a mid-to-high-end '11 workstation running Lion. Try going back to 3-year-old machine for a week, and I think you'll find it's kind of annoying, and your morale will die the death of a thousand papercuts.

I'll take one if you still have them. Thanks!

Leadership and management are orthogonal. There are managers who couldn't lead their team out of a paper bag, and there are great leaders with "Intern" on their business cards.

More importantly, there are leaders who aren't even _good_ at management tasks. Just because everyone trusts your opinion on architectural design doesn't mean you should be assigning tasks, or prioritizing the backlog.

Not likely. Apple's moved to a clang-based toolchain, haven't they?

Demos don't work on my droid. I keep getting the "Visit this site on your iPad" box.

As a Windows git user, this is a minor concern. msysgit works from cmd, powershell, and the include bash prompt, and the gitk and "git gui" tools are actually pretty good once you're familiar with the metaphors.

The one thing that still gives me the heebies is the CRLF handling, but I think that's because rails generates unix-style files, and I get a warning from git gui whenever I use those scripts.

Powershell:

    PS C:\> 0.1 + 0.2
    0.3

Not at all. Behind the compiler curtain, they're the same as functors (http://www.newty.de/fpt/functor.html)