ラベル translation の投稿を表示しています。 すべての投稿を表示
ラベル translation の投稿を表示しています。 すべての投稿を表示

2013年2月8日金曜日

僕のEclipseはどこ行ったんだ?(ゴミ箱だよ)

この記事はBrian Oliverさんの2013年2月4日のブログ記事「Where’s my Eclipse IDE gone? (into the Trash)」を勝手に翻訳というか意訳したものです。

一応本人に邦訳したよーって伝えるつもりですが、あまり正確に邦訳しているわけではないので、ご了承下しあ。


僕のEclipseはどこ行ったんだ?(ゴミ箱だよ)


10年間使ってきたEclipseをとうとうゴミ箱に葬ってやったよ。何でかって?あまりにも画面スクロールが不安定でカッとなったからだよ。もう、あれはダメだ。


えっとね、11インチのノートブックならいいんだよ。24インチのスクリーンだと遅いんだ。30インチのスクリーンでやった日には、動きやしない。ここで注意しておいておらいたいんだけど、ホワイトスペースにハイライトを入れて、行番号は表示しているんだ。これらの機能を使わなければ、まあ動くんだけどね。だけど、僕にはこれらの機能が必要だったから、もうどうしようもなかったんだ。


僕はいろんなリリースとか、パッチとか、ハックとか、設定まわりとか試したし、コードも読んだよ。でもね、結果としてこの問題を解決するよりもIDEを切り替えたほうが楽だということがわかったんだ。


というわけで、JetBrainsのIntelliJ IDEA11(と12)に変えたわけだ。それなりに使いづらいと思ったし、楽しくなかったんだよ。だって、僕は10年にもおよぶEclipseユーザーだからショートカットとかが手に馴染んでいるからね。とはいえ、生産的であるっていう意味では変えて正解だったと思ってる。今のところEclipseのキーマップを使っているけど、もう戻るつもりはないから、そのうちIntelliJのキーマップに慣れていくと思うよ。


幸運なことに僕のお気に入りのプラグインがサポートされてたんだ。特にJIndent。これは僕の6つのプロジェクトで多用しているやつだ。


結論。Eclipse、君は長い間最強のプラットフォームだったよ。でも今や君は(他のIDEに比べて)遅くて、重くて、低能なものになってしまったようだね。


PS IntelliJ IDEAのパーソナルライセンスは本当に買うだけの価値があるよ。

2011年6月5日日曜日

97 things Every Project Manager Should Know を読んでみた(2)

Avoid Whack-a-Mole Development

モグラたたき開発から逃げろ


開発する早さの評価に関するエッセイ。
日本のSIerではバーニーさんの方が評価される傾向にありますね。
ものづくり日本という標語が盛んに叫ばれたりしています。
でも、なんか年末になるといらない工事とかがあったりして、
作りっぱなし日本という標語が適切な気がしなくもないです。
だからこそ、読んでほしい一節です。

ちなみに、前回と同じく、翻訳の詳しいところはいい加減です。
翻訳はノリが大事です。
多分怪しいところは満載なので、ツッコミ歓迎です。
それと、オレには突っ込まないけど、オレだけ知ってウッシッシな人はGoogle 翻訳にでもかけてください。

SOFTWARE PROJECT MANAGERS faces a lot of pressure to deliver fast. Time is of the essence. How can you get things done fast?



Imagine you have two programmers on your team, Bernie and Rob. Both are capable, have the same amount of domain knowledge, and have equal language skills. During development, you find that Bernie finishes his feature implementations much faster than Rob.



While Bernie focuses on getting the code completed quickly, Rob spends time writing code and then refactoring it. He names the variables and methods better. Once he gets things working, he breaks the code into smaller pieces. Now he writes tests to make sure each piece of his code does what he meant it to do. When he's reasonably satisfied, he declares the coding of that functionality done.




But assume you don't know these details. If you only look at the speed with which the functionalities are declared done, clearly Bernie is the better man, right?



A few weeks go by, and you demonstrate the features to your customer. As usual, the customer loves your completed features, but now wants you to change and improve them. You ask your developers to make those code alterations. When you take the new and improved functionality back to your customer, they try out the features that Rob implemented and are pleased with the changes.



Unfortunately, they discover something odd with the features that Bernie implemented. While Bernie has programmed in the new functions fine, now a few things that worked before don't work anymore. The customer marks these as defects, and you ask Bernie to fix them. The customer tests the features again. Now even newer, stranger things seem to be broken. What's going on here?



If you have a child, you know what is happening. Bernie has created a Whack-A-Mole application. Whack-A-Mole is a toy. Kids are given a wooden hammer to strike moles that pop up at random. It's fun for them to be surprised by which mole pops up next. However, fixing applications with broken code popping up at random places is not fun. It is frustrating, unpredictable, and it slows your product development. Bernie was sprinting initially, but he was running in the wrong direction.



While Rob appeared slower at the outset, he was actually creating superior code. His pace proved sustainable. The better quality of his initial code helped him make workable changes quickly. Plus, the test he wrote in the beginning gave him instant feedback regarding whether or not his new code was compatible with other parts of the application where the code was used.



When measuring time for a feature implementation, do not consider only the time it takes to write it in the first place. Add the time it takes to enhance, fix, and improve the code. Writing good quality code and tests takes time. It appears to be a short-term loss. However, it comes with a long-term gain.

Ask yourself if you want speed, or if you want to savor sustainable progress.



ま、このブログを読む人なんて、えらいプロジェクトマネージャーなんかいないだろうけどね。
それと、お客さんに同じ機能のテストをさせるなんて、どう考えたってムダでしかない。
ソフトウェアを作りっぱなしで、お客さんになんども同じことをさせるのはどうかと思う。

2011年6月2日木曜日

97 things Every Project Manager Should Know を読んでみた(1)

表題のとおり、読んで、勝手に訳してみた。

今回はその最初のエッセイ『Get Users Involved As Early As Possible』。

ちなみに、オレの翻訳はかなり適当感満載なので、
各自Google先生に正しい訳を求めること。

オレが提供するのは英文が醸し出している雰囲気のみ。



PAST PATTERNS OF SOFTWARE DEVELOPMENT involved getting user requirements and then going off to do the coding and testing under a veil of great secrecy. After all, the users wouldn't understand what we were doing anyway, right? At the end of the project, our magician's magic cloth was whisked away and the user was expected to "ooh" and "ahh" at the brilliance of what we had produced. However, all too frequently the reaction was, "Well, I know you went to a lot of work, but what I really wanted was...".



Today, the secret to project success is to involve the users almost as soon as there is anything visible to show them. How much better it is to find out that there are problems with what we are developing early on, rather than after the project is complete!



Costs for changes become increasingly high the further along we are on the project schedule timeline. The time to recode, retest, and rework the immediate software, as well as to test integration with all the peripheral code involved, can delay the project substantially. And both time and cost baselines are jeopardized if a change is so major that it has to go through a lengthy Change Control Board process for approval.



Programming decisions over very minor issues, which make perfect sense to the software developer and the project manager, may create chaos back at the workstation when the software goes into use.



以下、2011/06/04に追記

I know of a large training company that spent $5 million redesigning its ordering software. Previously, the item numbers matched the product being ordered in a logical way. For example, 4125 might be a student manual, 4225 was the accompanying student exercise disk, 4325 could represent the instructor manual, 4425 was the course outline for marketing purposes, and so on. You could order all the items in the 4X25 series on the same screen



Each day, administrative coordinators in 140 locations around the world ordered the same kinds of materials over and over and soon memorized the item numbers. Once you knew the number for a student manual, you could immediately key in the numbers for the other items without looking them up, and ordering went quickly.



In the redesign, somehow the project team forgot to consider the way the ordering process was used by the real people doing it. Under the new design, there was no logical relationship between items. Item 6358 might be the same student manual that once was 4125, the accompanying student exercise disk was now 8872, and the instructor manual for the same class was 3392.




Not only did the user have to look up each item and try to "forget" the old numbers and system, but also each type of item was now on a separate page.

Administrative coordinators were furious. Ordering slowed to a crawl. The project far exceeded its time and cost baselines.

As a project manager, you should get the users talking to the software developers early and often.