Gas station without pumps

2013 November 11

labhacks — The $25 scrunchable scientific poster

Filed under: Science fair,Uncategorized — gasstationwithoutpumps @ 10:58
Tags: , , , ,

A friend just sent me link to  labhacks — The $25 scrunchable scientific poster:

Printed on Spoonflower performance knit at 300 dpi. 36”×56”, vivid colors, no unraveling, and minimal wrinkling, even after being stuffed in a backpack. Hangs straight with about 8 pins. Print cost is $22 with $3 shipping.

The idea is to use a service intended for custom printing fabric to print posters instead.  According to the web page for Spoonflower, the fabric printing company, the material is $21.60 per yard for the designer of the pattern:

Performance Knit: $24/yard ($21.60 with designer discount)

100% polyester fabric with moisture management

  • 56″ wide printable area (142 cm)
  • 4.1 oz per square yard
  • Optic white, produced in the US
  • Appropriate for athletic apparel
  • Estimated shrinkage: 1-2%
  • Weft directional stretch is 25% maximum
  • Wash separately in cool or warm water using a gentle machine cycle. Machine dry using a low temperature setting. If required, use an iron with a light touch on a synthetic setting only. Higher iron temperatures may result in color transfer and melting of fabric.

They also warn that

Our fabrics have not been treated with fire retardant chemicals and are for this reason not suitable for use in children’s sleepwear or bedding. They are also not suitable for display purposes in public buildings unless you apply such treatment after purchase.

I don’t believe that paper scientific posters are any more flame retardant than cloth ones, though the fumes may be a little less noxious, and burning paper does not stick to things the way that molten plastics do, so cloth posters may indeed need to be treated with flame retardants for safety if you plan to display them long term. A quart spray bottle of flame retardant (enough for about 6–7 posters) costs about $15 online.

Given the awkwardness of the standard poster tubes when traveling, I can see the attraction of the cloth poster, though I worried that it might a bit bulky to pack. But a 36”×56” poster would only weigh 6.4 oz, about the same as a t-shirt (I just weighed one of my t-shirts at 189g, which is 6.7oz), so it can probably be packed in about the same space as one or two t-shirts.

The biggest downside is that printing the fabric takes 10 days, plus shipping time.  Spoonflower does have a rush-order service with next-day service and 2-day shipping, so the turnaround time could be a small as 3 days, but I did not look up how expensive the rush orders and shipping are.

According to their help page,

Acceptable file formats are JPG, PNG, GIF, TIF, SVG, AI, and EPS, and the file must be less than 40 MB. Vector files (AI, SVG, or EPS) are converted to PNG format during the upload process at a size chosen by you.

Elsewhere they warn against sending vector files (SVG, AI, and some EPS files), because the files have to be converted to raster format before printing, and there are often surprises in the conversion process (they don’t say what conversion program they use, but I know that there are often problems with Corel Draw mis-interpreting SVG files—I’ve run into that problem with both laser cutting and T-shirt stencil design).

If you are careful in your use of images, the 40MB limitation should not be too bad.  I tested converting an old poster of mine from PDF to PNG at 300dpi, and it grew from 0.6MB to 6.4MB—still well within the 40MB limit.  I did not have any photographs on that poster, though, which makes a huge difference—plots and cartoons don’t take up nearly as much memory as photographic images.

Spoonflower also warns that their color gamut is different from most monitors and printers—they use water-based dyes that don’t do large areas of saturated colors or solid black areas very well, but they use more than 4 inks, so they can get a wider color gamut than most printers.  You can get a “color map” of 1500 color swatches printed on the fabric you plan to use for the cost of a yard of fabric (about $25).  They use an RGB color space and have ICC profiles available free for how the colors come out on each of their fabrics, so you can get a decent idea of how colors would come out if you use software that has a color management engine.

The person who sent me the link to labhacks was suggesting the cloth posters for science fairs, but I’m afraid they would not work there.  Most science fairs are based on table-top displays, not wall-mounted or easel-mounted posters, so science fair posters need to be free-standing.  Although one can devise means for hanging a cloth poster in the standard, it seems more complicated to me than a foldable foam-core or cardboard display, and the rig would be just as hard to pack and carry on airplanes as the foldable board. I’ve also not found any information on the Spoonflower site about maximum length restrictions for their printing.  Can they even do the standard 6′ tall science fair poster? (probably, but they only talk about sizes up to a yard).

I don’t think that Spoonflower is going to get inundated by orders for scientific posters, but think that a few people will find the ease of packing “scrunchable” posters attractive.  If I ever decide to start traveling to conferences again, I might try it myself.

Update 2013 Nov 12:

After I posted an announcement of this blog post to researchers at work, one sent me the following ad that they had just received from another company providing fabric posters.  I guess it is a trending fad.

New Solution for Conference Posters!

Take a long flight? Now you can put your fabric crease-resistant
poster in your carry-on and say goodbye to poster tubes.

Same Day Printing and 2-Day Delivery.

check our delivery schedule or visit us now: www.postersmith.com

($15 Off Coupon Code*: SABCS2013)

The fabric poster offered by PosterSmith.com is made of 100% high-density polyethylene fibers with UV inhibitor coating. This crease-resistant fabric is light and durable and is specifically designed for high resolution printing. Because of the UV inhibitor coating, the ink of our fabric poster will last much longer than a paper poster. The printing quality of our fabric poster is better than printing on the widely-used matte paper. Your poster printed on our fabric material will resemble the feeling of printing on a glossy paper (which has tighter surface and looks brighter) but generates no glossy paper’s reflective glare. *Coupon code expire 06/30/2014

Note, even with the $15 off, PosterSmith is a lot more expensive than SpoonFlower.

2013 November 10

Doctor Maker

Filed under: Uncategorized — gasstationwithoutpumps @ 16:49
Tags: , ,

I saw an announcement recently in Mark Guzdials’ blog, Doctoral Fellowships available in Computational Craft Lab | Computing Education Blog, announcing a doctoral fellowship for a “maker lab” position:

4-year Doctoral Fellowship in Digital Fabrication & Learning

Utah State University

Instructional Technology & Learning Sciences

Utah State University’s Instructional Technology and Learning Sciences (ITLS) department is pleased to announce the availability of a prestigious four-year doctoral fellowship for a new doctoral student interested in digital fabrication, the maker movement, and education. This involves bringing technologies as diverse as 3-D printers, sewable circuitry, low cost microcontrollers, and robotics to education.

The fellowship provides full tuition and a stipend for four years, beginning Fall of 2014. The fellow will work with two leading researchers in the ITLS department, Drs. Victor Lee and Deborah Fields,who have produced innovative work in the areas of creative learning technologies, craft and computation, informal and formal learning environments, online social networking sites, and STEM education. The fellow will have numerous professional development and networking opportunities as well as access to the newly created “Computational Craft Lab” with brand new equipment and materials for digital fabrication. Drs. Lee and Fields have a strong reputation for providing mentorship and time to doctoral students, involving them in all aspects of research and implementation.

This competitive fellowship is available for one student beginning doctoral studies in August 2014. Interested students should contact Victor Lee or Deborah Fields as soon as possible. Please include a resume and letter describing your research background, interests, and how they align with this fellowship.

Victor Lee: victor.lee@usu.edu
Deborah Fields: deborah.fields@usu.edu

I’m not sure what a PhD thesis from a maker lab would look like, but based on the the lab being located in a department that sounds like an edu-tech department, I wouldn’t expect much.

The “computational craft lab” sounds a lot like the OpenLab in the Arts Division at UCSC, except that the OpenLab is focused on “arts research” rather than “instructional technology”.  Quite frankly, I expect more interesting things to come out of the arts research, but sending prospective teachers through a maker lab experience would probably increase the quality of hands-on, experiential learning in our schools.

 

2013 November 8

Critiquing code

Filed under: Uncategorized — gasstationwithoutpumps @ 22:57
Tags: , , ,

In The Female Perspective of Computer Science: Why Arts and Social Science Needs Code: Testimonials, Gail Carmichael continues her “Why are we learning this?” guide for arts and social science students with “a set of testimonials from people in the field that learned to code.” I’ve pulled out a little piece of one testimonial here:

Emily Daniels, Software Developer and Research Analyst, Applied Research and Innovation at Algonquin College
http://www.emilydaniels.com/

As an artist you probably already have a thick skin developed by years of crits where others continually tear down your work and expect you to pick up the pieces. This will prepare you for similar responses to your programs and is also immensely useful in software development. It seems from my experience that most computer studies programs don’t spend nearly enough time preparing people to respond well to negative or constructive feedback of their work. [emphasis added] It would benefit a lot of developers to be able to take criticism in stride like an artist can, so if you can, you are ahead of the game.

I think that this is an important critique of many engineering programs, and of computer science programs in particular. Many students finish CS programs with high grades but are still unable to write good programs.  A big part of the problem is that no one has ever looked at their programs—certainly not critically, with an eye toward making the students better programmers through pointing out things that they have still not mastered. I think that CS may need to have more of the sort of criticism that a good studio art class or writing circle has: strong feedback about what needs improvement tempered with some praise for what is good. (I’m not a proponent of the “3 good for 1 bad” school of ego-stroking—that approach provides a lot of emotional support but very little improvement in performance.)

I try to provide strong feedback in my first-year grad course in bioinformatics, where I require eight programming assignments and two writing assignments.  The prior programming experience of my students varies, from students who’ve had just two introductory programming courses to students who have had BS degrees in computer science and 25 years as programmers in industry.  As a general rule, more experience in programming results in more competence at the programming assignments, and those with CS degrees do better than those without, but the differences are not as large as one would expect. I’ve had students who had earned straight As in several previous programming classes but who could not produce adequate programs even for the “warm-up” assignment in three tries (with extensive feedback on the first two).  I’ve also had students who had only one or two prior programming classes work very hard and produce adequate (though not stellar) programs, even on the more difficult assignments near the end of the course.

For many of the students in my course, I am the first person to read their code, no matter how many previous programming courses they have had.  I’m often also the first person to give them feedback on their variable names, comments, and docstrings—the things that the compiler ignores but which are crucial for anyone trying to understand the code.  Many of the students have no idea how to write a program that can be read by someone else (or even by themselves in six months), because they have never written anything but throwaway code, and no one has taught them the difference between good programming practice and throwaway programming.

What are the differences between the really good programmers, the adequate programmers, and the poor programmers?  Is there any way to predict who will rise to the challenge and who will fall flat?

The really good programmers seem to be the smartest (they also do very well on the written work that does not include programming), and they are very good at decomposing problems into sensible subproblems that can be clearly described and independently implemented and tested.  The cleanness of their problem decomposition leads to clean data structures and simple functions that are easy to document.  I believe that many of them write their docstrings (defining what the functions are supposed to do) before writing the code that implements it.  Most of the top programmers have had a lot of previous programming experience, but not everyone with a lot of experience turns out to be a good programer.  I don’t think I end up teaching the good programmers very much about programming—mainly I reinforce habits that they might otherwise have been tempted to let slide, since no one else seemed to care.

The adequate programmers do fairly reasonable problem decompositions, slightly awkward data structures, and code that is almost right.  They often debug their programs into existence, messing up on subtle boundary conditions.  Their variable names tend to be vague, giving some indication what is in the variable, but not a precise indication of the meaning.  They often make mistakes that result from interpreting a variable one way in one part of a code, but slightly differently in a different part of the code.  Their documentation seems to be an attempt at explanation after their code is finished and more or less working—it provides them no help during the time they spend debugging, which is most of their time. Their programs are often several times longer than the programs by the good programmers, because they added a lot of unnecessary special-case code, to compensate for awkward program decomposition or data structures.

Many of the adequate programmers can become good programmers, with some help in learning how to decompose problems more cleanly.  One of the best ways I can think of for getting them to improve is to have them write their docstrings before they code the functions, to provide terse but fairly complete external descriptions of those functions.  If they can’t come up with terse, clean descriptions, then they’ve probably done the decomposition wrong, and a little more time spent on thinking about the problem at a high level will probably save them a lot of debugging time later on.  Getting them to focus on the precise meaning of their variables and data structures and getting them to think about edge conditions probably has a lasting impact on their programming ability. I see enormous improvements in some of these students over the 10 weeks I have them in class, and I like to think that the huge amount of time I spend on providing feedback has a lasting effect, not just a do-it-for-the-class-but-never-again effect.

The poor programmers decompose the problem in random ways, often with highly inappropriate data structures (like copying an I/O format as an internal representation).  The awkward decomposition results in functions that cannot be tersely described, since the entire environment in which the function is embedded has to be just-so for the function to have any meaning at all.  Their variables usually have meaningless names (like “flag”, “i”, or “args”) or highly misleading names (like “kmer” for the length of a string, rather than for a length-k string).  Their code is often poorly tested, crashing on standard uses cases or obvious boundary conditions.  In many cases it looks like the students have tried to “evolve” their code—making random mutations to the code in the hope of increasing its fitness.  As in biology, most mutations are deleterious, so this approach to programming only works if you make millions of tries and use very strict selection criteria.

I think that many of the poor programmers who have had several programming courses have only worked on “scaffolded” assignments, where they fill in the blanks on programs that someone else has decomposed for them.  They have never decomposed a problem into parts themselves, and have no idea how to go about doing it.

I don’t know how to convert the poor programmers into adequate programmers—I can point out their problems to them and suggest better decompositions or better data structures, but I don’t know whether they will learn from that. Many can take specific suggestions (about variable names or data structures) and implement the changes, but there does not seem to be much transference to the next problem, where they again do random decompositions of the problem and use meaningless variable names.  In many cases, I think that the muddiness of their code reflects muddiness of their thinking (their writing in English is often similarly disordered and confused).  If they are new to programming, there is hope that with practice they will learn to think more precisely, but if they have been programming for a while and are still flailing, I have no idea how to help them.  Luckily I don’t get many really poor programmers—most tend to drop after the first couple of assignments, realizing that their usual programming style is not going to get them through the course.

I have had students switch from being poor programmers to adequate programmers (in one case after failing the course three times and succeeding on the fourth try), but I don’t think I can take any credit for the improvement—I didn’t do anything differently on the fourth try than on the previous three. I’ve also had one student fail four times, so it isn’t just that I give up and pass students who aren’t doing the work.

I don’t generally fail students until near the end of the course—when earlier work is not up to passing quality the grade I give is “REDO”.  I expect students to redo the work fixing the problems that I’ve identified and resubmit it.  Many students do learn from the redone assignments, and start turning in adequate work the first time. For many of the weaker students, it may take more than one round of “redo” before their work is of high enough quality. A few never seem to get it, and make the same types of mistakes in assignment after assignment.

After about three assignments, I can tell pretty much how well the students will do for the rest of the course.  The top programmers on the first three assignments will continue to do well, often improving their coding in minor ways as they pick up the little bits of feedback I can provide them.  The adequate programmers who are striving to become good ones and the adequate programmers who are content to stay at their current skill levels are also evident.  I’d like to spend the most time on feedback for the adequate programmers striving to become better—they are the ones most likely to benefit (they are also usually the majority of the class).  In practice, though I spend most of my grading time on the bottom of the class, trying to figure out what is going on in really unreadable code.  I am sometimes tempted to triage the grading, with little time spent on the good programmers or the hopeless ones, and if the class were much larger I’d have to do that, but so far I’ve been trying to provide useful feedback to everyone.

I have yet to find any good way to predict who will do well before I’ve read the first two programs.  Number of CS courses, grades, or years of programming experience are only weak predictors.  I suspect that I might get more useful predictions from SAT scores or IQ tests measuring general intelligence, but I don’t have access to that information.

« Previous Page

%d bloggers like this: