เวลาเขียน SwingBuilder แล้วปกติพอเวลาจะ add component ชื่อตัวแปรมันก็จะอยู่ในสโคปของ closure พออยู่นอก scope ก็หาไม่เจอ วิธีแก้คือใช้ id อ้างอิง แล้วใช้ method getVariable(id) ในการเรียก element เอา คิดง่ายๆ ว่าเหมือนกับเขียน HTML แล้วใช้ getElementById()

โรงแรมแคปซูล สัญลักษณ์แห่งประสิทธิภาพการใช้พื้นที่สำหรับการนอนหลับ

แต่ก็ยังต้องชิดซ้าย เมื่อเจอกับสิ่งประดิษฐ์ชิ้นใหม่ นั่นคือ

มันคือโต๊ะออฟฟิศแนวใหม่ คับแคบพุงแมกซ์

เราจะขอเรียกว่าโต๊ะแคปซูล!

เจ๋งดีอ่ะ!

ถ้าสนใจติดตามงานเจ้าตัวเพิ่ม ดูได้ที่ http://www.youtube.com/user/aomjaija เลยครับพี่น้อง มี cover เพลงอื่น และเพลงไทยอีกต่างหาก

ติดตามไปฮากันโดยพลัน

ไม่ว่าอย่างไร ใครอย่าได้พูดทีเดียวว่า “เรียนไปไม่เห็นได้ใช้เลย” ถ้าหากเมื่อใดที่คุณรู้สึกว่างานที่ทำไม่ได้ใช้ความรู้ที่เรียน สิ่งที่เป็นไปได้มีแค่ 2 อย่าง คือ

1. คุณดันหลงไปทำงาน labour
2. คุณใช้ไม่เป็นเอง

และทั้งสองทางล้วนเป็นอุปสรรคต่อความก้าวหน้าในหน้าที่การงานของคุณ

หรือเราต้องสร้าง product นอกกลุ่ม labour ขึ้นมาหว่า?

ที่มา: เรื่องเล่าจากวิศวกรหญิง พันทิป.คอม

ธนาคารไทยพาณิชย์ สาขาสภากาชาดไทย
บัญชีบริจาค: “สภากาชาดไทย เพื่อการรับบริจาค” (เพื่อช่วยเหลือผู้ประสบภัยแผ่นดินไหวที่ประเทศเฮติ)
หมายเลขบัญชี 045-2-88000-6

พร้อมส่งใบโอนเงินไปที่  คุณ ภารดี  วนกุลหัวหน้าฝ่ายการเงิน สำนักงานการคลัง   สภากาชาดไทย  หมายเลข  FAX   0-2250-0120
พร้อมระบุ ชื่อ–นามสกุล  หมายเลขโทรศัพท์ติดต่อให้ชัดเจนเพื่อขอรับใบเสร็จ

ติดต่อเพิ่มเติมที่: 0-2256-4035 – 6

ที่มา จากสภากาชาดไทย

รายงานข่าวฉบับเต็มดูได้ในโพสต์ใน narisa.com

ข่าวอย่างเป็นทางการติดตามอ่านต่อได้ใน PMSE

งานนี้ Hard Sale กันสุดฤทธิ์เลยกู 555+

ต้องขอโทษด้วยที่รีวิวนี้เอาร้านโมโมทาโร่ไปเทียบกับ Ramen Tei เต็มๆ แต่ก็อดเทียบไม่ได้ เพราะ ขายของแบบเดียวกัน ร้านอยู่ตรงข้ามกัน (ตรงซอยธนิยะ) ราคาไม่หนีกันมาก (ชามเล็ก 100 – 120 ชามปกติ 150 – 180) ดูยังไงๆ ก็คู่ชกรุ่นเดียวกันนี่หว่า ลุยกันเลย! (รูปประกอบนี้เป็นของร้านโมโมทาโร่ทั้งสิ้น ของราเมนเทไม่มี)

เริ่มต้นจากหน้าร้าน หาทางเข้ายากพอกัน ดูมึนๆ เหมือนกัน ตัวอักษรไทยอันขนาดเพ่งตาบอดเหมือนกัน ร้านนึง (Ramen Tei) ก็เอาใบไผ่มาปิดหน้ากระจกไว้ให้รู้ว่านี่คือกำลังจะเข้าไปสู่ป่าแพนด้าแล้วนะ อีกร้านนึงดีหน่อย มีป้ายแดงๆ ห้อยอยู่ด้านหน้าให้รู้ว่านี่คือร้านอาหารนะ แต่ก็ติดฟิล์มดำซะเพ่งหน้าร้านไม่รู้ว่ามันทำการรึเปล่า หมัดนี้เสมอกัน

บรรยากาศในร้านโมโมทาโร ซอยธนิยะ มุมไม่ค่อยดีเท่าไหร่ - -"

ต่อไปว่าด้วยบรรยากาศ โมโมทาโร่ บรรยากาศร้านสไตล์ญี่ปุ่นแท้ๆ ออกแนวเก่าๆ หน่อย นึกถึงหนัง Always ยุคนั้นแหละ ใช่เลย มีนั่งพื้น + เสื่อ, นั่งโต๊ะ + เก้าอี้ไม้ และ Counter หน้าครัว บรรยากาศไฟสลัวๆ หน่อย แต่ไม่เปิดเพลง (ถ้าจำไม่ผิดนะ) น่าจิบเบียร์นั่งคุยกันมาก ผมว่าอย่าง Ramen Tei มันสว่างเกินไป เวลาคุยกันออกรสออกชาติไม่สนุก ฮ่าๆๆๆ

ราเมนแกงกะหรี่ของร้านโมโมทาโร โปรดสังเกตุขนาดเทียบกับขวดพริกไทย

เส้นของโมโมทาโร่จะหนากว่าของ Ramen Tei ส่วนรสชาติผมว่ายังไม่สู้ Ramen Tei เพราะไปสั่งหมี่ผัดทะเล เทียบกับโกยซีหมี่ของ Ramen Tei ที่อยู่ตรงข้ามกัน ต้องถือว่าชั้นเชิงภาษีของ Ramen Tei นั้นดีกว่า รสชาติและเส้นมันเข้ากันกว่า แต่โมโมทาโร่ผัดไม่มันเท่า Ramen Tei อีกทั้งมีมัสตาร์ดมาดับความเลี่ยนให้ เลยให้บวกคะแนนไปอีกนิดนึง

ราเมนแกงกะหรี่นี่ใช้ได้เลย กินแล้วไม่รู้สึกว่ากำลังข้าวแกงกะหรี่ที่ใช้เส้นแทนข้าว (บางร้านกินแล้วรู้สึกอย่างนี้จริงๆ) ผมว่ากำลังกลมกล่อม
ยกเว้นเกี๊ยวซ่านั่น อร่อย! Oishiii! ตามสไตล์ด้านหนึ่งกรอบ อีกด้านนิ่ม
โดยรวมก็ถือว่า OK ผมว่าด้อยกว่าหน่อยนึง (บางคนก็บอกว่าอร่อยเด็ดกว่า Ramen Tei ดังนั้นอย่าเชื่อผมมาก 555+)

การบริการ เนื่องจากไปเวลาคนไม่เยอะ ดังนั้น สั่งเร็ว ได้เร็ว พนักงานว่างให้เรียกเกือบตลอดเวลา ชาจีนเติมตลอด

เกี๊ยวซ่า (หายไปแล้ว 1 ชิ้น) กับหมี่ผัดทะเล ร้านโมโมทาโร่

ความคุ้มค่า ระดับห้ากะโหลก!!!!! ที่เห็นถ่ายมาน่ะ ราเมนแกงกะหรี่ชามเล็กนะจะบอกให้! ส่วนหมี่ผัดน่ะชามปกติ! ลองสังเกตุเทียบกับขนาดขวดพริกไทยดูเพราะขวดนั่นน่ะมาตรฐาน โอ้โห ใครจะไปกินหมดวะ สั่งราเมนชามเล็ก ตอนเขายกชามเล็กมานี่ ถามก่อนเลย “ชามเล็กแล้วเหรอพี่?” ขนาดสัก 75 – 80% ของชามปกติ Ramen Tei เห็นจะได้ แทบจะพอดี 2 ชาม 3 คน แบบแน่นหน่อยแล้ว ตอนเดินข้าร้านเห็นเขายกราเมนเต้าหู้ เห็นแล้วสงสัยว่านี่ยกมาทั้งหม้อเลยเหรอ อลังการมาก! เลยไหวตัวทันสั่งชามเล็กกัน เดินออกมาแทบไม่เห็นโต๊ะไหนกินหมดสักโต๊ะ (รวมถึงไอ้โต๊ะราเมนเต้าหู้ด้วยเพราะเป็นฝรั่งมากันสองคน คนนึงสั่งราเมนเต้าหู้ อีกคนสั่งหมี่ผัดทะเล มีเบียร์อีก เหลือเกือบครึ่งได้) โคตรจะเยอะ

ตอนผมสั่ง ดันสั่งกัน 2 ชามเล็ก 1 ชามใหญ่ + เกี๊ยวซ่า ตอนท้ายทุกชามเหลือเส้นประมาณ 1/3 ชาม คือกินเส้นไปไม่เยอะเน้นกินเนื้อแล้วนะ ยังอิ่มโคตร ถ้าจะสั่งพอดีอิ่มและกินกันไม่เยอะ ขอแนะนำว่าให้สั่ง ชามเล็ก 2 ชาม 3 คน แล้วก็เกี๊ยวซ่าอีกหนึ่ง เช็คบิลได้ออกมาจะราวๆ คนละร้อยต้นๆ ไม่หนีฮะจิบังสักเท่าไหร่ถ้าสั่งน้ำ + ทาโกะมาแกล้มด้วย คุ้ม!

โดยสรุป ร้านนี้เหมาะกับการไปนั่งยาวๆ กินเบียร์แล้วก็โม้กันมากกว่าราเมนเทเพราะบรรยากาศดีกว่าและคุ้มกว่า รสชาติดูด้อยกว่า แต่ก็ยังถือว่าดี ฟันธง!

Beware RECURSIVE method!

This is such an obvious evil that you may already known this. If you’re working with processing the list result and get stack overflow error then I suspect you’re somehow using recursive method. Avoid that if possible. One method I had discovered to lead to stack overflow is dropRight since I use this method in order to reduce list size. Others also had shown that foldRight could cause this error as well. If you want to know which method may harm you then you may tries using scala interpreter and construct List of integer that the size is larger then 4K elements. However if you REALLY want to know then I suggest you go for source code.

Immutable List should be use cautiously.

Why? Because Immutable is not mutable! That means the list may not change over time, and the only way to add / remove element by using immutable list is to return a new list. If you’re trying to constantly append the processing result into a list by the end of each iteration, then you are going to reassign list every iteration. This could drain your memory real fast. My alternatives is that you may prefer scala.collection.mutable.ListBuffer instead.

Watch out for linear-time method usage while processing lists

Since processing multiple files may yield a list of result for each iteration, which each element had to be stored in another list (with same index). Writing codes like this within main file reading loop:

for ( i <- 0 until loopResult.length ) {
    //Some other process also going on
    processResult(i) += loopResult(i)
}

had cost me extra 60 seconds comparing with this loop when I’m processing files in byte-by-byte fashion, with each loop result had 20 elements. (Be advised that my actual logic is more complex than this but just to show the idea)

for ( elem <- loopResult.zipWithIndex ) {
    //Some other process also going on
    processResult(elem._2) += elem._1
}

And it even could be optimized with using zip command like below. However I haven’t tried it myself so I cannot guarantee this is better.

for ( elem <- loopResult zip processResult ) {
    elem._2 += elem._1
}

Processing “result list” after file reading loop if possible.

It’s reasonable to processing file to get result for each loop and append it into a result list. However if you may require extra processing e.g. sort the list or filter out N least element, then it’s better to process these after you’ve complete reading the file because processing these stuffs will usually lead you to O(n^2) when n = file size. You can even use immutable list and sort method for this case. For my case, I had to filter out the least element to reduce the size of the list from 300K to 40K. It took less than a few seconds when I process this after completely processing whole file, comparing to forever (It tooks so long and I kill its process) when I tries to achieve this within file reading loop.

If you’re interested in processing large files, then don’t forget to read Processing large files with Scala as well. His contribution really saves my ass since I totally have no idea on what to start at all.

However I do believe these might not fit everyone since you usually don’t have to work with large list. Some tips might also slow your coding speed down so please adjust this tips accordingly to your need.

That’s it for what I’ve discovered. You guys can share or even comments about this since I’m just a scala (and functional language) newbie.

Edit: Rewrite in easily-readable style.

ที่มา: pcmag withinWindows
ที่ไป: Port25 (แถลงการณ์จาก Microsoft)