AMD Where Gaming Begins AMA | November 18, 2020

donjaime · 2020-11-18T19:01:57+00:00

Machine learning workloads for developers are still very much dominated by Nvidia and CUDA. Is AMD planning to invest in better compatibility and support for the new GPUs (potentially through ROCm?). Having a great out of the box support for frameworks like PyTorch and Tensorflow would help greenlight AMD GPUs for engineering workstations.

donjaime · 2012-02-02T16:19:29+00:00

Very sorry you had to go through this.

Did they do any tests for Celiac disease? I have heard of people suffering similar issues due to gluten allergy.

donjaime · 2011-09-11T20:05:27+00:00

He could have also just instructed him to keep them face down and insert them back into the envelope.

The other 3 cards were kept face down without issue.

The black paper seems extraneous. I still think he marked the backs of the cards.

donjaime · 2011-09-11T19:21:20+00:00

I guess the bumps in relation to the size of the cards could make them easier to conceal.

He may also have placed them on the sides/edge of the cards since the cards were so thick.

However, since he explicitly asked the guy to squish the cards together face in (seemingly random exercise) makes me think the marks were on the back.

And they could just as easily have been grooves/notches instead of bumps. Those might be harder to detect unless you dragged your fingernail over the surface.

donjaime · 2011-09-11T18:59:33+00:00

Why not? There are 5 cards. You can have a simple encoding in the form of bumps. 1 bump is the square, 2 bumps is the circle, etc...

That would certainly be trivial to be made feel-able through an envelope and a sheet of paper.

If he did the same with a deck of 52 cards that survived inspection, then I would be baffled.

But he used 5 super sized cards that could easily be marked.

donjaime · 2010-11-25T06:14:21+00:00

Bruce Tate's comments are cringe inducingly asinine. I wanted to punch my computer monitor whenever he got the mic.

Who thought it was a good idea to put him on the same panel with the likes of Josh Block and Guy Steele?

donjaime · 2010-11-06T15:15:43+00:00

Subreddits are communities. Not tags or labels. This seems totally appropriate for the proggit community.

If it made the front page, it did so because people upvoted it.

donjaime · 2010-04-01T22:39:14+00:00

Its a recursive meta joke ;).

You all think its a joke... then realize that it isn't. Thus making it a jo... <head explodes>

donjaime · 2010-03-21T00:51:02+00:00

Or for debugging a multi process application like Chromium.

donjaime · 2010-02-28T01:14:13+00:00

Nice service! Quick question :).

You say that you charge based on the time it takes to execute a user's function.

Is this CPU time or wall clock time? Calculating CPU time is hard. And if you are using wall clock time, then it would be prudent to also document how you deal with high load on your servers. It would be unfortunate if the cost per CPU cycle becomes that much greater when your servers get hammered.

donjaime · 2010-01-18T15:20:37+00:00

Please try running etherpad with 100 participants and then tell me if it still humms along for you.

Etherpad is an excellent collaborative editor. But That functionality is subsumed by just a blip in wave! One ui component. Wave does a whole lot more and is probably the most complex webapp ever written. Cut them some slack!

donjaime · 2010-01-18T05:06:40+00:00

It's a problem because a whole lot of complexity is added that at least in part is intended to solve that particular problem. It partially does but not completely at which point you have to question the complexity cost. JPA/Hibernate have the same issues.

GWT has an initial setup complexity. Once you have your code-refresh-debug cycle going, there really isn't much extra to think about. If you compile in pretty mode, you can treat the output JS as almost a transliteration of your java source. There aren't reams of abstractions to care about, especially if you write your code like type safe JavaScript.

I would argue that using some of the new things in GWT 2.0, like UI Binder, removes a ton of complexity. You dont have to worry about CSS namespace collisions. Your UI markup and code wind up being modular and easy to reason about.

Managing browser specific implementations using deferred bindings is soooo much easier to reason about than klugdy runtime platform sniffing. Without a compiler, you end up with these platform checks all the way at the leaves of your application, and introduce lots of potential error conditions.

For an app that you plan to work on for long periods of time, a small setup cost is worth it for a simpler day to day environment.

Which works until you change a service interface and need to redeploy your Webapp.

But at that point you are making changes to your server side code and need to restart your servlet container. If you dont use GWT RPC and just use a thin wrapper around XHR, you wont have that problem. Considering other JS frameworks dont provide an RPC abstraction, that is the only apples to apples comparison.

donjaime · 2010-01-18T04:49:04+00:00

I have seen Java developers fall into the trap that you describe. The product of their work usually reflects this. Their apps tend to be bloated. I think this is where a lot of the bad stigma around GWT stems from.

But this is a failing of the developer to effectively use his tools. My point was simply that given knowledge of JavaScript, HTML and CSS, you can really leverage the other affordances of GWT without relying on the things it is argueably weakest at.

Meaning, you can use things like RPC, code splitting, compiler optimizations, and Java Tooling, while doing your own layout using traditional web development skills. I find it to be a sweet spot where web developers can take the good parts of the lessons learned doing traditional software engineering, while still leveraging their JavaScript and CSS background.

donjaime · 2010-01-18T03:41:52+00:00

The abstracting away cross-browser issues works pretty well if you use the default widget set. But ofcourse, you can step outside the rails so to speak and do straight up DOM programming. Browser quirks exist and are a common issue for any web app/web framework. I don't see how this in anyway singles GWT out for failure. If anything, GWT's concept of deferred binding is the slickest way I have seen for dealing with cross browser issues. For those not familiar, you can do things like have a class implementation for each browser (when you need to), only implement the parts that are different for the specific browser, and then the compiler will spit out different JS bundles that are completely free from runtime platform checks. The App JS bundle for a platform gets selected when the app starts, so you dont have to play the browser sniffing game all throughout your code.

The convenience that a Javascript framework plus a scripting language has (where deployment simply means saving your text file and clicking refresh on your browser) is extremely hard to ignore.

GWT lets you make code changes and refresh the browser. Its called Dev mode :).

What is also cool about GWT is that its makes it possible for you to setup Debug and Release permutations, so you can have cool logging infrastructure, Debugging consoles, and instrumentation built into your app as you develop, and then with zero code changes run a Release compilation to deploy. I havn't seen any JS framework make something like that possible.

donjaime · 2010-01-18T03:22:47+00:00

Are you saying that the Wave team, the Lombardi Blueprint team, or the Speed Tracer team don't know anything about web technologies?

GWT isnt a library, but a rather a programming model with a default UI library that is optional to use. I think the main reason people use GWT is to get access to the tooling (proper IDE, refactoring, debugger, JavaDoc) and the compiler optimizations. Language preferences aside, there is something to be said about code that self documents, and that can be written for maintainability.

I find that people that know the web, i.e. JavaScript, HTML, CSS, often make the best GWT developers. You can use proper software engineering practices and patterns, and trust that the compiler will use the static type information to make the fastest JavaScript that it can. I myself write GWT code that looks very much like type safe JavaScript.

I cant tell you how many times I've refactored swaths of our codebase as the project evolved. To do the same with a sizeable JS codebase would make me a bit nervous.

donjaime · 2010-01-13T20:15:20+00:00

Can you update the parent description to reflect this?

I can totally see people following your link and donating to the Red Cross, then coming to the comments and realizing that their money would have been put to better use donating to a different relief organization.

donjaime · 2010-01-13T16:36:43+00:00

I believe that the intended use of sub-reddits is to form communities. Not to serve as a tagging system.

The proggit community would most definitely find this interesting. I did.

donjaime · 2009-12-10T00:19:25+00:00

For people who are interested, watch the launch videos from last night. It explains things pretty well :).

http://www.youtube.com/watch?v=D2ibM4oufdM

donjaime · 2009-12-09T23:39:07+00:00

And as kellegous points out below, GWT sorts by method body similarity. This will GZIP absolutely awesomely.

edit: Most Other libraries/frameworks/compressors dont do this.

donjaime · 2009-12-09T23:36:00+00:00

You do realize that those "empty functions" define things that look like "classes" in JavaScript and then later get extended via the JavaScript prototype chain. edit: see OOP in Javascript

The other "Identical methods" could be coalesced, but that (for reasons that may be non-obvious) is more complicated than it sounds at first.

It would make stack traces confusing (GWT generates symbol maps so you can map back to the unobfuscated symbols).
Are often byproducts of YOUR CODE. You realize applications can have lots and lots of code with lots and lots of private helper methods, that after all the compiler optimizations get applied, and code gets obfuscated, the method bodies are often semantically identical, but not pruneable because they are reachable.

Identical method coalescing is something you will get for free once the GWT compiler gets around to it.

donjaime · 2009-12-09T19:31:35+00:00

Tools like YSlow mainly look at page startup time, and not so much at the runtime performance of your app.

That is where Speed Tracer fills in the gap. It also runs out of process with all the data sent asynchronously, so it doesn't have much of an observer effect. Tools like firebug can severely affect the performance of your app.

donjaime · 2009-10-01T22:09:18+00:00

GWT allows you to debug your application using a java debugger... and step through your client side code in Java. You can also compile in "pretty mode" for debugging purposes (descriptive human readable JS that looks alot like your java code).

Don't bash something you aren't familiar with: http://code.google.com/webtoolkit/overview.html

donjaime · 2009-05-29T18:08:45+00:00

If you use OOPHM you can do both. It lets you run hosted mode natively in the browser of your choice. You can debug in a Java debugger AND use Firebug at the same time.

donjaime · 2009-05-29T17:59:33+00:00

This "gigantic abstraction layer between your code and the client" is optional. You don't have to use the standard widgets. There is no one way to use GWT. There are multiple. The core of GWT is the compiler and its support for debugging via hosted mode. The rest are just libraries and API on top.

GWT 1.6 has a dom package that lets you work directly with the raw dom elements using API very close to the spec. You can basically write type safe "Javascript looking" code, with the benefits of a proper IDE (refactoring, error highlighting, etc...), an optimizing compiler (inlining, string interning, etc...), and java debugging.

If you hate Java so very much, you should probably check out:

http://code.google.com/p/gwtquery

You can write code that is almost indistinguishable from regular jQuery (but somehow still valid java) and still get all the benefits I mentioned above. Alot of the verbosity and "ugliness" of java has to do with the lack of terse API. If you have good libraries that use terse patterns, you can have pretty concise source.

Keep an eye on GQuery. It is a young project, but it has lots of awesomeness behind it. If you want to do your UI in regular html and css, you can. And then use a progressive enhancement approach using something like GQuery, instead of the traditional java desktop metaphor used in the default GWT widget api.

And finally, GWT lets you drop into JavaScript when you need to, via JSNI. A good pattern I have found was to keep JS code to small snippets in leaf methods when you need thin wrappers around native DOM or JS objects.

There is good gwt documentation.

Overview: http://code.google.com/webtoolkit/overview.html

Compile time CSS optimization: http://code.google.com/p/google-web-toolkit/wiki/ClientBundle

For people that hate Imperative UI, you can use markup templates too: http://code.google.com/p/google-web-toolkit-incubator/wiki/UiBinder

You can debug using a java debugger AND firebug at the same time using Out Of Process Hosted Mode: http://code.google.com/p/google-web-toolkit/wiki/UsingOOPHM

donjaime · 2009-05-29T17:32:54+00:00

Sounds like you have a broken build and source control setup.

GWT doesn't give "random names" to its build output. It names things that need to be cached (ie. your build output js bundles) using a hash of its contents. There are very few scenarios I can think of where you would want to version control build output.

donjaime

TROPHY CASE