Marco Scata

Easy Buns

2018-01-01T03:42:00.000+11:00

Ingredients for 12 buns

Yeast: 1 sachet dry or 30g fresh
Sugar: 50g
Milk: 250ml
Water: 125g
Eggs: 2 at room temperature
Olive Oil: 50g
Flour: 600g "strong" bread flour
Salt: 2 teaspoons

Instructions

Dissolve the yeast in the water with a tablespoon of the sugar. Place it in the oven with the light on and leave it for about 10 mins, until a thick froth has formed. DO NOT SWITCH THE OVEN ON! Just leave it with the light on and the door closed.
In the meantime, beat the eggs and warm up the milk. The milk should be just a little warm to the touch. Not hot. If it's hot, the yeast will die. I usually blast it for 20s in the microwave straight from the fridge.
Mix all the dry ingredients in a bowl: the flour, the salt and the remaining sugar.
Add the beaten eggs, the olive oil, the milk, and the frothy yeast mixture to the last drop.
Use a wooden spoon to combine everything. You just need to combine all ingredients. It doesn't matter if it's lumpy. It should be a thick sticky batter. [see pics 1 and 2]
Cover with a towel or cling film and put it back in the oven. This should still be SWITCHED OFF and with the light on. If you have a cooking thermometer, you can play with the oven settings to maintain the temperature at around 30'C.
Leave to rise for about 2 hours. It should more than double in volume. You should also see bubbles on the dough. [see pic 3]
Take the bowl out of the oven and squash the dough to get rid of most bubbles. You can give it a gentle stir but try to not to knead it. The dough should still be sticky but very stretchy. [see pic 4]
Take a baking tray and lay a sheet of baking paper on it. Then brush the paper with olive oil. Do not use a flat cookie tray. It needs to have a little bit of depth. Mine has a depth of 1cm.
Now you need a well floured worktop and you can start making the buns. This recipe is for 12 buns so you can kind of guess how much of the dough you should use for each bun. Personally, I don't care if some end up slightly bigger and some others slightly smaller. They all get eaten, regardless. I use a dough ball that is slightly smaller than my fist to make one bun.
To shape the buns, roll each ball on the floured worktop, then pick it up and let it relax on the palm of your hand. Use the other hand to pinch up the edges to make something that looks like a little money bag, then turn it around and tuck the edges underneath to make a dome-shaped bun and place it on the baking tray. Do this one or two dough balls at a time. If you divide the whole bowl into 12 balls and let them rest on the worktop, they might stick to the worktop and become more difficult to handle. [see pics 5 and 6]
Gently brush each bun with olive oil and loosely cover them with cling film. Do not seal them tight. They need room to rise. Leave them in a warm part of the kitchen for about an hour. They should just about double in volume and almost start merging into each other. [see pics 7 and 8]
Bake for about 20 minutes at 180'C. I use a ventilated oven. I also use a water sprayer bottle as soon as I put them in the hot oven. Two or three sprays and quickly close the oven door. It seems to help building a nice crust.
Keep an eye on the buns. Yours might take more or less than 20 mins. A nice warm golden-brown color will tell you they are ready. [see pics 9 and 10]
Enjoy.

Pictures

Trying Continuous Delivery - Part 3

2013-12-24T21:26:00.000+11:00

Please note: I am making this stuff up as I go along, so I may have to update each post at a later stage to reflect some changes that I think might make things easier to manage.

In my previous post I set up the basic environment that will host my application for Integration work. Now I can start writing the application and put it into a continuous delivery pipeline. The purpose of these posts is only to put into practice some of the principles of continuous delivery, so I will not spend much time writing about the details of the web application. In fact, the application will be a simple noticeboard, where anyone can write a new post and anyone can read all posts in the system.

I set up my application in Eclipse as a Maven project and start writing my acceptance tests right away. I could use behavioral testing frameworks like JBehave or easyb, but I will keep it simple and use plain JUnit tests written in a format that still defines and asserts application behavior. Just as a useful practice, I like separating my tests into packages that reflect their general purpose:

Package Name	Tests Purpose
mywebapp.tests.unit	These will test small pieces of functionality. They run very fast and are not supposed to test multiple application layers, so they use test doubles (mocks, stubs, etc) when needed.
mywebapp.tests.integration	These will test multiple application layers (e.g. services and data access) and run a bit slower than unit tests.
mywebapp.tests.acceptance	Arguably the most important type of tests. These are translated directly from requirements/stories. They are usually the slowest tests to run.

This separation strategy allows me to do a couple of things that will be very useful once I start shaping my delivery pipeline (which will be the subject of a later post):

Run individual test suites from Eclipse by right-clicking the relevant package and choose Run As -> JUnit Test
Separate the test suites in Maven by using simple include directives for the Surefire Plugin and the FailSafe Plugin
Run faster tests early in the feedback cycle and slower tests only after all the faster tests have succeeded

More packages would eventually emerge as I start to automate other types of tests (performance, capacity, etc), but these will suffice for now.

All my acceptance tests will follow a given-when-then pattern, and my first acceptance test will check that anyone is able to add a new comment on the noticeboard.

package mywebapp.tests.acceptance;

import org.junit.Test;

public class AnyVisitorCanWriteNewEntryTest {
 
 /**
  * Loads the noticeboard page.
  */
 private void givenTheNoticeboardPage() {
  ...
 }

 /**
  * Fills the noticeboard form with a new entry.
  */
 private void whenAnonymousUserWritesNewNotice() {
  ...
 }

 /**
  * Submits the noticeboard form.
  */
 private void andSubmitsForm() {
  ...
 }

 /**
  * Examines the noticeboard table and tries to find the
  * unique comment that was used to submit the form.
  */
 private void thenAnonymousUserCanSeeTheNewEntryOnNoticeboardPage() {
  ...
 }

 @Test
 public void anonymousUserCanWriteNewEntry() throws Exception {
  givenTheNoticeboardPage();
  whenAnonymousUserWritesNewNotice();
  andSubmitsForm();
  thenAnonymousUserCanSeeTheNewEntryOnNoticeboardPage();
 }
}

The test will clearly fail because I haven't written any application code yet. It is meant to simulate user actions on a web interface, so it follows a WebUI-centric pattern:

Load a web page
Find some element on the page, e.g. an input box
Perform some operation on the element, e.g. change one of its attributes
Perform some action on the page, e.g. submit a form
Check the result, e.g. different elements are displayed on the page

However, this doesn't necessarily have to be the case for acceptance tests on a web application: if the presentation layer is well decoupled from the business logic (as it should be), then acceptance tests could exercise the business logic directly instead. Either way, there are some important tradeoffs to consider. For example, a UI-centric approach will almost certainly depend on page elements having specific names and/or IDs, which can change many times during the application's development lifecycle and waste valuable feedback cycles and spend valuable development time maintaining and fixing tests that will seemingly break for no reason. On the other hand, one could argue that exercising the business logic directly and bypassing the presentation layer altogether does not actually simulate any user interaction and is therefore not good enough to be considered a "proper" acceptance test. My purpose here is to provide an example for continuous delivery, so my choice of following a UI-centred approach is irrelevant in this instance, but the main point here is that there must be automated acceptance tests as part of the continuous delivery feedback cycle.

From the acceptance test I can work my way down to more granular tests that eventually translate into application code, using a test-driven approach. I won't go into any of those details here, but I will introduce some profiles in my pom.xml in order to neatly separate the different types of tests for my delivery lifecycle.

<profile>
    <id>unit-tests</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            ...
            <configuration>
              <includes>
                <include>**/mywebapp/tests/unit/**/*.java</include>
              </includes>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
    <profile>
      <id>integration-tests</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <skipTests>true</skipTests>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            ...
            <configuration>
              <includes>
                <include>**/mywebapp/tests/integration/**/*.java</include>
              </includes>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
    <profile>
      <id>acceptance-tests</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <skipTests>true</skipTests>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            ...
            <configuration>
              <includes>
                <include>**/mywebapp/tests/acceptance/**/*.java</include>
              </includes>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>

It's probably worth noting the use of skipTests in the integration-tests and acceptance-tests profiles in order to specifically skip the execution of the Maven surefire plugin.

Why did I use profiles? Why didn't I just manage all tests in the main build block? I don't think there is one single right answer here, but my preference for continuous delivery is to neatly separate the different types of tests into individual jobs in Jenkins. By doing this, I can potentially distribute the load of slow acceptance tests across several Jenkins slaves running in parallel, based on the names of test classes or their sub-packages.

For now, I just need 3 Jenkins jobs to run my tests:

Job Name	Execution
MyWebapp-Unit-Tests	mvn clean test -P unit-tests
MyWebapp-Integration-Tests	mvn verify -P integration-tests
MyWebapp-Acceptance-Tests	mvn verify -P acceptance-tests

In particular, the job running acceptance tests will package the application into a war file and deploy it to Tomcat before executing the tests. This can be accomplished by using the maven tomcat plugin or Cargo. Yes, I could use Jetty just for testing, but I need to make sure that my acceptance tests are run against an environment that is as similar as possible to my production environment, so I don't want to test on Jetty if I already know that I'm ultimately going to deploy to Tomcat.

... TO BE CONTINUED ...

Applying selected principles of effective teaching and learning

2013-11-28T23:02:00.000+11:00

Applying selected principles of effective teaching and learning to each of the four macroskills of listening and speaking, reading and writing.

Several authors have tried to extract some fundamental principles of language teaching and learning, intended as fundamental factors that have a positive impact on the effectiveness of teaching and learning languages, supported by research and observation in second language teaching and acquisition. This essay will examine two of these principles - meaningful learning and motivation - and how they apply to each of the language learning macro-skills: listening, speaking, reading and writing.

Brown (2000) proposed twelve learning principles divided in three categories (cognitive, affective and linguistic); Savignon (2002) and Brandl (2007) each extracted eight principles from research in Communicative Language Teaching (CLT); Ellis (2008) - also based on CLT research - extended the number of general principles to ten. Aside from the specific linguistics domain, identifying generally applicable principles of learning and teaching has also been an important concern in general education. The OECD, for example, extracted five general teaching principles from a number of case studies on education systems across several countries (2008), while various departments of education at national, state and local level identify and use very similar core principles in their published pedagogical frameworks (Education Queensland, 2011; Education Victoria, 2004).

Even though the above research has been developed in different areas, there seem to be some significant similarities across the principles listed by different authors and organisations, and sometimes the same principles are identified under different labels in different publications. For example, Brandl’s principle of recognising affective factors has a strong connection (although more general in scope) with Brown’s principle of intrinsic motivation.

There also appears to be a significant amount of interdependency between various principles, so that their effects on the learning process cannot be examined entirely in isolation from one another. For example, experience suggests that using rich and realistic material for learning (the principle of authenticity) makes it easier to design and carry out meaningful learning activities (the principle of meaningful input), building students’ comfort and familiarity with real-life situations in the second language (the principle of self-confidence), engaging the students’ interest and providing students with a positive stimulus for effective learning (the principle of purpose or motivation).

There are two important aspects that should be differentiated with regards to meaningful learning. The first aspect is the intrinsic meaning of the exchanged information (whether it is comprehensible or not). The second is the internalised meaning of such information (whether participants can personally and situationally relate to it or not), and evidence suggests that it is this second aspect that has a stronger, positive impact on language learning.

According to Brown (2000), communication acquires meaning when the participants find an association between the information being exchanged and their internal representation of the world as manipulated by activities that are commonly carried out. In other words, there should be a connection between the elements of communication and familiar situations. From a pedagogical perspective based on theoretical principles, it follows that meaningful learning can be addressed by designing and carrying out content-based activities that are purposeful, functional, and relevant to the learning objectives (Raimes, in Richards & Renandya, 2002).

Modern constructionist and communicative approaches place substantial emphasis on constructing and exchanging meaning (Canale & Swain, 1980; Krashen, 1982; Savignon, 2002; Richards, 2006; Ellis, 2008), so even though different authors may use different words and labels, they still refer to the same core ideas: that language teaching and learning should be focused on real goals (Brown, 2000), immediately recognisable references (Savignon, 2002), active construction of meaning, relevant content (Ellis, 2008), purposeful exchanges on information, and engaging activities with content that is relevant to the learners’ experiences (Richards, 2006).

With regards to motivation, both research and experience support the concept that motivation stems from the anticipation of rewards, which act as a constructive drive in the learning process. Achievement-based (extrinsic) rewards provide positive feedback for correct behavior and answers, but the most powerful rewards are those generated from within the learner (intrinsic) according to his or her needs and desires (Brown, 2000; Ghuman, 2013).

There is evidence of a positive relationship between motivation and effective language learning (Brown, 2000; Richards & Renandya, 2002). However, it is difficult to see how intrinsic motivation could be taught, because it is by definition an internal state of mind. Nevertheless, research suggests that it is possible to facilitate the emergence and growth of intrinsic motivation by means of various tasks and activities that empower the learner, build up learner autonomy and responsibility for his or her own learning journey (OECD, 2008; Richards & Renandya, 2002), fostering individual accountability (Richards & Rodgers, 2001), providing sufficient opportunities to interact (Ellis, 2008), and engaging learners’ interest (Savignon, 2002).

Researchers seem to agree that both the listening process and the reading process are carried out along two related but very different tracks: bottom-up and top-down processing (Richards & Renandya, 2006). During bottom-up processing, the listener/reader first decodes the language input starting from its basic building blocks (e.g. spoken sounds or written words), using contextual information, inference and prior knowledge to construct meaning. During top-down processing, the listener independently constructs meaning in his or her mind based on prior knowledge and expectations, using and interpreting the language input to track and actively adjust the meaning. Bottom-up and top-down processing are both believed to happen recursively.

In any case, if we embrace the view that language is an expression of thought and society (Fromkin et al., 2011), then the listener’s ability to construct meaning is greatly influenced by the degree in which the language input matches the listener’s internal representation of the world, which is what makes communication meaningful. Research suggests that the use of schemata and scripts is therefore of great importance in the construction of meaning (Richards & Renandya, 2006).

Applying the principle of meaningful learning to listening involves designing and carrying out activities in which learners can relate prior knowledge to information processing in the form of language input, not only by recalling and activating existing schemata and scripts, but also by facilitating the construction and refinement of new ones (Nunan, in Richards & Renandya, 2006). In order to provide a meaningful listening activity, teachers should also focus on the development of listening strategies like predicting the continuation of sentences ahead of the speaker, or raising awareness of suprasegmental features like stress, tone or word junctures (Van Duzer, 1997).

With regards to motivation, activities can be designed around songs or games for younger learners at a basic level, for example using a command-action model (Asher, 1977), whereas more mature learners at intermediate level might be more successfully engaged in activities that relate to their day-to-day activities, like a dialog at the family doctor’s office, or the local news.

Listening skills are of paramount importance in the development of speaking skills (Richards & Renandya, 2006), and there seem to be various similarities in the development of speaking skills between first language acquisition and second language learning. In theories of first language acquisition, children learn to speak only after spending sufficient time listening. Through listening, children learn to recognise language patterns and real world associations, which they will try to reproduce through speech at a later stage using various strategies like babbling and imitation (Fromkin & al., 2011). Second language learners also tend to develop listening skills first, going through a silent period before they start to develop their speaking skills (Krashen, 1982).

Brown and Nation (1997) recommend carrying out three types of speaking activities: form-focused (centred on pronunciation, grammar and vocabulary), meaning-focused (centred on communication), and fluency-focused. In particular, they suggest using form-focused activities with learners at basic level, moving on to meaning-focused activities as the learners’ language proficiency increases.

The principle of meaningful learning can be applied to teaching speaking skills by carrying out activities that are authentic and purposeful (Shumin, in Richards & Renandya, 2006), while also addressing the development of more specific linguistic competences: grammar, discourse, sociolinguistic, and strategic (Canale & Swain, 1980; Savignon, 2002).

In order to foster motivation, speaking activities can be modelled around the students’ real interests. For example, young learners might enjoy singing or telling simple mime stories, in which the students try to recite a story according to actions mimed by the teacher, whereas more mature learners might be more interested in role playing activities.

In the context of listening and speaking, meaningful communication is constructed by all participants using an interactive exchange of information by using various discourse strategies. In the context of reading and writing, meaningful communication is instead built into the text by the writer, and is extracted by the reader in completely independently, so that the text becomes a communication proxy or filter between the reader and the writer.

Grabe (2004) points out that functional discourse structures in a text are interpreted by the reader according to conventions and patterns, and familiarity with those helps the construction of meaning. This might be driven - for example - by similarities between the culture of the writer and that of the reader, or by the reader’s prior knowledge of the subject. In cases where the reader has little or no familiarity with the text, pre-reading activities can be carried out in order to build up awareness in and basic knowledge of the cultural, sociolinguistic, historical, and technical/factual aspects of the text. Pre-reading activities are also useful to build up relevant schemata and scripts that are so beneficial for top-down and bottom-up processing (Van Duzer, 1997).

Since non-verbal elements can make up as much as two thirds of a verbal conversation (Hogan & Stubbs, 2003), one of the biggest challenges in teaching and learning writing skills lies in developing the writer’s ability to produce text that is meaningful to the reader (Byrne, 1988), especially considering the practical impossibility for the reader to interactively and recursively negotiate meaning with the writer to clarify or disambiguate the language being used, which would be a natural discourse strategy in the spoken language.

One way to help writers in producing meaningful text is to try to develop the ability to visualise an audience and to identify a clear central idea that writers will then wish to convey to that audience (Seow, in Richards & Renandya, 2006). With an audience in mind, the process of writing can also be enriched by the writer taking the role of the reader in order to extend and refine the produced text, iteratively switching between the two roles until the text is complete.

Reppen (in Richards & Renandya, 2006) proposes creating opportunities for free expression as well as carrying out realistic situational writing activities in order to define the potential audience and engage the students’ interest, for example writing letters to relatives in junior classes, or writing cover letters to potential employers in more mature classes. In all cases, focusing on the text instead of its constituent parts (sentences or paragraphs) makes the learning process more meaningful and motivating (Byrne, 1988).

Seow (in Richards & Renandya, 2006) recommends building motivation by encouraging students to evaluate their own and each other’s texts, and potentially presenting their final work to others in the form of interactive post-writing activities like presentations, enactments, or reading aloud and discussing, thereby complementing writing activities with reading acitivities. Ferris (in Richards & Renandya, 2006) points out that the process of editing a text is often neglected when teaching writing skills, and this can lead to poor results. Therefore, building up students’ motivation to engage in the editing process can be beneficial, and Ferris suggests to do so by raising the students’ awareness of the positive effects that editing has on the final writing product, for example by marking the students’ unedited work and compare it against the mark that the students could have received for the edited work.

Marco Scata

References

Asher, J. J. (1977). Learning another language through actions: the complete teacher’s guidebook. Los Gatos, CA: Sky Oaks Productions.

Brandl, K. (2007). Communicative language teaching in action: putting principles to work. New Jersey: Pearson Prentice Hall

Brown, H. D. (2000). Teaching by principles: An interactive approach to language pedagogy (second edition). New Jersey: Prentice Hall Regents.

Brown, R. S., & Nation, P. (1997). Teaching speaking: suggestions for the classroom. The language teacher online, January 1997. Retrieved from http://jalt-publications.org/old_tlt/files/97/jan/speaking.html

Byrne, D. (1988). General principles for teaching writing. Teaching writing skills (pp. 25-29). London: Longman.

Canale, M. & Swain, M. (1980). Theoretical bases of communicative approaches to second language teaching and testing. Applied Linguistics, 1, 1-47.

Education Queensland (2011). Pedagogical framework. State of Queensland department of education. Retrieved from http://education.qld.gov.au/curriculum/pdfs/pedagogical-framework.pdf

Education Victoria (2004). Effective pedagogy: principles of learning and teaching P–12. State of Victoria department of education. Retrieved from https://www.eduweb.vic.gov.au/edulibrary/public/teachlearn/student/poltleadchangepedagogy.pdf

Ellis, R. (2008). Principles of instructed second language Acquisition. CAL Digests. Retireved from http://www.cal.org/resources/digest/instructed2ndlang.html

Fromkin, V., Rodman, R., & Hyams, N. (2011). An Introduction to Language (ninth edition). Canada: Wadsworth, Cengage Learning.

Grabe, W. (2004). Research on teaching reading. Annual Review of Applied Linguistics, 24 (1), 44-69. USA: Cambridge University Press. doi:10.1017/S0267190504000030

Hogan, K., & Stubbs, R. (2003). Can’t get through 8 barriers to communication. Grenta, LA: Pelican Publishing Company. Retrieved from http://www.kevinhogan.com/downloads/8Mistakesp.pdf

Krashen, S., (1982). Second language acquisition theory. In Principles and practice in second language learning and acquisition (pp. 9–32). Oxford: Pergamon.

LIN8002 Methodology in teaching a second language: Study Book. (2013). Toowoomba: University of Southern Queensland.

Mahmood, T., Ahmed, M., Shoaib, H., & Ghuman, M. (2013). Motivation as pedagogical technique for teachers: a cross comparison between public and private sector. Mediterranean journal of social sciences, 4 (2), 563-570. Rome: Sapienza University.

OECD (2008). Assessment for learning. Formative assessment. In OECD/CERI International Conference “Learning in the 21st Century: Research, Innovation and Policy”. Paris: OECD. Retrieved from http://www.oecd.org/site/educeri21st/40600533.pdf

Richards, J. C. (2006). Communicative language teaching today. New York: Cambridge University Press.

Richards, J. C. & Renandya, W. A. (2002). Methodology in language teaching: An anthology of current practice. Cambridge: Cambridge University Press.

Richards, J. C. & Rodgers, T. S. (2001). Approaches and Methods in Language Teaching. Cambridge: Cambridge University Press.

Savignon, S. J. (2002). Communicative language teaching: Linguistic theory and classroom practice. Interpreting communicative language teaching contexts and concerns in teacher education (pp. 1–27). New Haven: Yale University Press.

Van Duzer, C. (1997). Improving ESL learners’ listening skills: at the workplace and beyond. ESL Resources: Centre for Adult English Language Acquisition. Retrieved from http://www.cal.org/caela/esl_resources/digests/LISTENQA.html

Key approaches and methods in second language teaching

2013-11-28T22:58:00.002+11:00

Discuss a range of key approaches/methods in second language teaching that have been identified and gained traction in the literature as best practice. Illustrate how two (2) of those methods can be applied in a contemporary classroom including examples of interactions and written communication among second language learners and with their teacher.

Methods of language teaching have evolved rapidly between the late eighteenth century and modern days. Advancements in transportation and technology have been driving people’s mobility to higher levels across geopolitical boundaries, favoring the rise of wider international economies and labor dynamics. This process has also made it easier for people to move across linguistic boundaries, and the resulting pursuit of multilingualism has been a powerful driving factor for approaching language teaching methodologies in pragmatic and systematic ways. This essay will discuss a range of language teaching methods and the approaches they follow, providing examples of how two of them in particular (Communicative Language Teaching and Total Physical Response) can be applied in a contemporary classroom. The distinction between “approach” and “method” in this essay will follow the terminology formulated by Anthony (1963), according to whom an approach is the establishment of a set of assumptions used in the processes of teaching and learning, and a method is the way an approach is used to teach (and learn) a language in a systematic way. Also, this essay will use the terms “target language” and “first language” to indicate, respectively, the language being learnt in the classroom and the language usually spoken outside of the classroom.

The Grammar-Translation method was historically used to learn classical languages like ancient Greek and Latin, and is based on structural linguistic theories. In a Grammar-Translation classroom the teacher is usually in full control of the classroom activities, which are focused predominantly on the target language literature in a highly structure fashion, but taught exclusively in the students’ first language. The primary skills used are therefore reading and writing, with speaking and listening being underdeveloped or even disregarded altogether. Students learn how to translate literary texts of varying complexity, memorising grammar rules, constructs, and vocabulary. Just as in a Latin class students would learn to read and translate classical authors like Cicero and Caesar very early, students in a German class would learn to read and translate Goethe and Schiller. The emphasis is on producing the correct form of the target language through translation, therefore errors are not tolerated and are corrected by the teacher right away. This teaching method is driven by the belief that the most important aspect - the essence - of a language is its structure, and in order to learn and appreciate the language one needs to learn and appreciate its structure above all. Since grammar represents by definition the building blocks of linguistic structure, it is only natural to drive all intellectual efforts towards the understanding and the mastery of grammar and metalinguistic aspects of the language. One of the main criticisms of the Grammar-Translation method falls on the belief that building an encyclopaedic knowledge of linguistic rules and structures is synonymous with mastering a language. François Gouin’s first-hand experience with learning German at the end of the nineteenth century is an evident case to show the exact contrary, in which he was able to translate literary works but was completely unable to understand the spoken language - “not a single word” (1892, p.31).

Given the inability of the Grammar-Translation method to develop the communicative abilities of language students, new teaching methods started to appear. Building on his prior failures in the study of the German language, Gouin devised what came to be known as the Series Method: a way of building up linguistic knowledge through practical examples, transforming “perception into a conception” (1892, p.39). A Series Method class is therefore conducted entirely in the target language, using simple sentences at first in order to introduce an action or a situation. Sentences are then progressively enriched with more linguistic features towards higher and higher levels of complexity. For example, the teacher might start a basic class by walking to the desk and performing a series of simple actions while describing them to the students:

I walk to the desk.

I grab the chair.

I pull the chair.

I sit on the chair.

I grab a book.

I put the book on the desk.

As sentences are connected, and as complexity increases only in relatively small increments between sentences, meaning is inferred from sensory context and grammar is learnt by induction. The principles of small incremental comprehensible input and learning language through language use were further developed by Krashen in a more comprehensive theory of second language acquisition (Krashen, 1982). The Series Method then evolved into what is known as the Direct Method, based on Gouin’s principle that second language learning should not be much different from first language learning. The fundamental cognitive approach of the Series Method is retained, but the classroom becomes an interactive partnership between teachers and students instead of being entirely teacher-driven. The main belief behind the Direct Method is that students must be able to directly associate language and meaning, focusing primarily on developing speaking and listening skills. Students are therefore encouraged to initiate interaction and to correct themselves and each other when possible. One of the main criticisms of the Series Method and the Direct Method was the lack of solid theoretical foundations (Brown, 2000). Also, it presented a number of practical challenges because teachers needed to develop a new set of skills in order to direct the learning away from structured static study focused on grammar towards interactive dynamic activities focused on meaning.

As the mobility of people and resources increased dramatically during and after the Second World War, the need arose to find some ways to teach and learn foreign languages in the fastest possible way: from a military perspective, knowing the languages of enemies and allies was a distinct competitive advantage; from a socio-political perspective, masses of migrants fleeing conflict zones needed to be integrated in the host countries; and from a functional-practical perspective it was necessary to cross linguistic boundaries in order to efficiently drive socio-economic and industrial redevelopment, especially in Europe and in Northern America. As a result, the Audio-Lingual Method was developed on the foundations of behavioral psychology and adopted with relative success, focusing on learning specific linguistic structures within predefined practical linguistic domains. A common exercise in the classroom would be to present a situational dialog to the students and direct them to imitate and repeat each part of the dialog multiple times at specific intervals, aiming for accuracy in the language production. Over time, the presented dialogs would exhibit variations and drive the learning of different linguistic patterns. Imitation and repetition would then inevitably build up familiarity and confidence in the production of the target structures and the cultural context inferred by the presentation of those structures. One of the characteristics of the Audio-Lingual Method is overlearning: the process of getting so intimately familiar with a set of linguistic structures and patterns that their usage becomes automatic in circumstances and dialogs that bear similarities to those experienced during the learning process. With such a heavy focus on learning linguistic patterns, attention to grammar and metalinguistics is not a high priority and is often disregarded altogether, in favor of learning it inductively by analogy. Criticisms of the Audio-Lingual Method arose after Chomsky’s reservations on the relevance of behaviorist psychology in language learning (1959), and after all the main assumptions behind this teaching method were analytically dismantled by Rivers (1966).

Given the challenges and criticism found in the earlier mechanical forms of language learning, teaching methods were starting to shift away from heavily mechanical approaches, looking for techniques and strategies that would combine the focus on linguistic patterns with some form of meaningful context. Context is, of course, intended to be meaningful for students, and therefore teaching methodologies needed to be more mindful of the students’ personal characteristics and the ways in which they actually learn. In order to successfully assimilate language, learners need to use it in some practical context, and this context needs to be meaningful. Krashen later developed this and other concepts much further, noting that language acquisition is a subconscious process in which “language acquirers are not usually aware of the fact that they are acquiring the language, but are only aware of the fact that they are using the language” (1982, p.10). Following both cognitive and affective approaches, the Total Physical Response method took shape. In the Total Physical Response method, teachers give commands to students, and students execute those commands by performing physical actions. Teachers may well join in, and commands are carefully modified and recombined in order to provide students with linguistic content that, even though it might be a bit beyond their comprehension (Krashen, 1982), is still understandable by inference or induction. Learners are not expected to engage in language production and they are free to do so whenever they feel ready. It is very important to recognise that, even without writing and speaking, “there is a huge amount of listening, understanding and internalising going on” (Scrivener 2011, p.324). This needs to be considered under the evidence that listening is a skill that children develop long before speaking, and following the approach that learning a target language is cognitively analogous to learning a first language, hence the focus on kinaesthetics and the manipulation of the environment (Asher, 1978).

It is worth looking at the Total Physical Response method in a little more detail and provide an example in a contemporary classroom. In a basic classroom for children the teacher might be leading in with the topic of “morning activities”. The teacher would introduce a sequence of sentences, one at a time:

Wake up

Stretch

Sit up

Stand up

Scratch your head

Scratch your belly

Walk to the bathroom

Look at the mirror

Make a funny face

Make a serious face

Brush your teeth

Dress up

Eat breakfast

Wash up

Pick up your school bag

Pick up your hat

Open the door

Go outside

Turn around

Close the door

Turn around

Go to school

The teacher would act each command and encourage all students to do the same. Using different commands that have a common syntactical structure (e.g. “make... ...face”, “pick up...”) helps students infer both lexicon and grammar, while the acting and participation help associating words and sentences with direct experiences that are much more likely to get assimilated into long-term memory than any purely mechanical linguistic exercise. The similarities with the Series Method and the Direct Method are evident, but the Total Physical Response goes much further, building a tight coupling between language, sensory information, and the manipulation of the learner’s environment through actions, in a dynamic interactive setting where students and teachers actually participate in building and reshaping the linguistic context being studied, becoming themselves part of the overall teaching and learning canvas.

With Total Physical Response, Language learning started to be considered something more than a purely mechanical process leading to the formation of habits, and eventually functional linguistics started to develop. The focus was shifting towards teaching language as a means for communication and expression, under the belief that building communicative competence would then lead to – and ultimately include – linguistic competence (Canale & Swain, 1980). Increased importance was then given to the social and situational contexts in which linguistic interactions were taking place. According to Halliday (1973), language evolved as part of the process of performing specific functions in a social context; it logically follows then that language should be learnt and taught within defined social and functional contexts, rather than being extracted or abstracted from them as a totally independent domain. Communicative Language Teaching follows a functional/communicative approach, aiming at building up the linguistic tools that allow language users to convey meaning through communication. Errors in language production are part of the natural learning process and are therefore accepted, as long as they do not interfere with the exchange and negotiation of meaning. Students are encouraged to interact with each other and to give feedback to each other. The teacher provides the initial setup for classroom activities and loosely manages the classroom dynamics while students tackle the activities in small groups. Activities are usually centred around specific linguistic problems defined by information gaps that exist within a given social context, and students will have to decide how to best fill those gaps, choosing what to say and how to say it, establishing and maintaining the flow of information within their groups, engaging “with text and meaning through language use and discovery” (Savignon 2002, p.22). Linguistic forms are taught relative to the functions being targeted, but are neither emphasised nor strictly enforced, with the focus being on negotiation of meaning and discourse. The role of the teacher is that of facilitator, while students can focus on their own learning process and progress through authentic communication (Brown 2000, p. 43).

Communicative Language Teaching is considered to be the “generally accepted norm in the field” (Brown 2000, p.42), but there is no specific syllabus, as it is more of a generic term to indicate more a philosophy than a defined methodology, and is consequently open to interpretation. It is therefore worth providing an example of how Communicative Language Teaching principles may be applied to a contemporary classroom. Considering an intermediate-level classroom for adults, the teacher might decide to focus on the development of fluency and direct the class to perform some role-playing activities. For example, the teacher would lead in with a presentation of pictures that set the stage at a restaurant. Students would first describe and discuss the pictures in small groups in order to frame the social and linguistic contexts. Each student in a group would then be given a role to play, e.g. customer, waiter, chef, concierge, and a specific situation (or a number of situations) to be developed, like booking a table, suggestions for a meal, dealing with a difficult customer, making a mistake in the order, or handling an expired credit card. Students would improvise throughout the class and continuously provide feedback through discourse, thereby putting them in charge of their own and each other’s learning.

This essay has examined a number of key methods in second language teaching that have raised interest in linguistic circles and academia. Since the systematic study and analysis of language teaching methodologies started relatively recently in humanistic terms, there is still much to say as to how language teaching methodologies will evolve in the future. The very notion of a language classroom has changed so much over time, from a room with walls and desks to a distributed virtual space that only exists as a stream of digital information. Contemporary teaching methods for languages as well as other subjects seem to have some common aspects, like the encouragement of interaction, the use of varying instructional methods to meet diverse student needs, and the active involvement of students in the learning process (OECD 2008, p.6). As time goes by and societies evolve, new linguistic challenges will emerge and the language teaching profession will have to provide at least some of the means in the social transformation to work on those new challenges, creating valuable personal assets and competitive advantages.

Marco Scata

References

Anthony, E. M. (1963). Approach, method, and technique. English Language Teaching, 17(2), 63-67.

Asher, J. J. (1977). Learning another language through actions: the complete teacher’s guidebook. Los Gatos, CA: Sky Oaks Productions.

Brown, H. D. (2000). Principles of language learning and teaching (fourth edition). New York: Addison Wesley Longman.

Canale, M. and Swain, M. (1980). Theoretical bases of communicative approaches to second language teaching and testing. Applied linguistics, 1, pp. 1-47.

Chomsky, N., (1959). A review of B. F. Skinner's verbal behavior. Language, 35(1), pp. 26-58.

Gouin, F., (1892). The art of learning and studying foreign languages (second edition). London: G. Philip & Son.

Halliday, M. A. K., (1973). Explorations in the function of language. London: Edward Arnolds.

Krashen, S., (1982). Second language acquisition theory. In Principles and practice in second language learning and acquisition (pp. 9–32). Oxford: Pergamon.

LIN8002 Methodology in teaching a second language: Study Book. (2013). Toowoomba: University of Southern Queensland.

Richards, J. C., (2006). Communicative language teaching today. Cambridge: Cambridge University Press.

Richards, J. C., & Renandya, W. A. (2002). Methodology in language teaching: An anthology of current practice. Cambridge: Cambridge University Press.

Rivers, W., (1966). The psychologist and the foreign-language teacher. The French review. 39(4), pp. 636-638.

Savignon, S. J., (2002). Interpreting communicative language teaching contexts and concerns in teacher education. New Haven: Yale University Press.

Scrivener, J. (2011). Learning teaching. The essential guide to English language teaching (third edition). Oxford: MacMillan.

City Quiz for iPhone

2013-07-20T15:27:00.001+10:00

I liked this little quiz game. Here are the solutions.

Dubai
London
Paris
Amsterdam
New York
Los Angeles
Moscow
Rome
Male
Beijing
Milan
Florence
Chicago
Athens
San Francisco
Toronto
Sydney
Barcelona
Delhi
Puerto Iguazu
Miami
Munich
Monaco
San Diego
Tokyo
Cairo
Istanbul
Lhasa
Brussels
Las Vegas
Hong Kong
Prague
Montreal
Bangkok
Geneva
Melbourne
Shanghai
Rio de Janerio
Dublin
Punta Cana
Mecca
Lisbon
Vatican
Houston
Havana
Venice
Berlin
Dallas
Jerusalem
Washington
Madrid
Taipei
Atlanta
Bucharest
Edinburgh
Valencia
Lima
Luxor
Copenhagen
Shenzhen
Marrakesh
Petra
Stockholm
Zurich
Auckland
Ho Chi Minh
Seattle
Singapore
Chiang Mai
Agra
Palermo
Macau
Mexico City
Ushuaia
Buenos Aires
Bogota
Boston
Siem Reap
Bali
Oslo
Budapest
Orlando
Seville
Kiev
Cancun
Vienna
Manila
Chennai
Cannes
Pattaya
Kathmandu
Antalya
Jakarta
Honolulu
Warsaw
Ha Noi
Santorini
Sao Paulo
Seoul
Riyadh
Goa
Phnom Penh
St Petersburg
New Orleans
Kuala Lumpur
Phuket
Cape Town
Vancouver

Enjoy!

Trying Continuous Delivery - Part 2

2013-05-23T23:20:00.002+10:00

In the previous post I set up my development tools and my virtual UAT environment, using Subversion to control configuration changes to UAT. Now I can introduce automation in my setup.

There are several platforms that can help with automation, and they all do pretty much the same thing (execute jobs) in slightly different ways, but my vote goes to Jenkins for a few reasons:

It's free.
It's a mature platform with a very large user base.
It is plugin-based, so I can install and configure only the functionality that I actually need.
I can see fairly easily which plugins are actively maintained and use only those.
It's really easy to use.

I could install Jenkins on my laptop using apt-get, but since I already have a local Tomcat I will just download the war file and run it inside my Tomcat container. Later on I will use Tocmat to also run Artifactory, but I shall leave that part for another post.

Jenkins is already a usfeul platform "out of the box", but for my setup I need to add more functionality. There are many plugins available to add new functionality to Jenkins and integrate with different tools and platforms. However, for the purposes of configuring a job, I want to avoid using plugins as much as possible, relying on shell commands instead. This is not always feasible or practical, but that's the intention. The reason is that in a contingency situation where Jenkins might be unavailabl e I can always retrieve the shell commands from the Jenkins configuration and execute them by hand if needed. If I had to rely on Jenkins plugins to do the work for me, I wouldn't be able to keep things going in a contingency scenario. For example, if one of the steps in a Jenkins job was to publish a file to Artifactory, and I used the Artifactory plugin to perform that step, then in the event that Jenkins becomes unavailable I would have to devise a different way to publish the file (for example using Maven, or logging in to Artifactory and using the deployment page). This, however, contravenes one of the principles of continuous delivery: executing a task the same way every time. On the other hand, if I use a sequence of shell commands to achieve the same purpose, then I can always retrieve that sequence of commands from source control and execute it by hand if necessary, thereby operating still within the guidelines of continuous delivery. In many cases I could even temporarily use a cron job until I manage to get Jenkins back online, and nobody would even notice the difference.

Having said that, there are plugins that relate to Jenkins administration activities that I am very fond of. One of them is the SCM Sync Plugin. This plugin allows me to easily store and maintain all the Jenkins configurations (global and job-specific) into source control. Once configured, every change I make to a job's configuration or to the global configuration will be automatically checked in to source control. I create a new subversion repository, configure the SCM Sync Plugin to hook up to it, and check that the initial import worked before I move on.

laptop$ mkdir -p ~/svnrepo/jenkins
laptop$ svnadmin create ~/svnrepo/jenkins
laptop$ svnserve -d -r ~/svnrepo --foreground --log-file ~/svnserve.log --listen-host 192.168.56.1

(a different shell)

laptop$ svn list svn://192.168.56.1/jenkins/trunk
config.xml
hudson.maven.MavenModuleSet.xml
hudson.scm.CVSSCM.xml
hudson.scm.SubversionSCM.xml
hudson.tasks.Ant.xml
hudson.tasks.Mailer.xml
hudson.tasks.Maven.xml
hudson.tasks.Shell.xml
hudson.triggers.SCMTrigger.xml
scm-sync-configuration.xml

This helps tremendously in a disaster recovery scenario where I might have to rebuild the Jenkins server from scratch, in which case I would simply check out the configuration from source control before starting up Jenkins. This is a very efficient and effective way of reconstructing the pre-disaster state of Jenkins exactly the way it was. Even in normal circumstances, I will now be able to revert to a previous known good state in case I happen to make some configuration changes and mess it up really bad, or even just if I don't particularly like the end result for whatever reason.

Now I can create a new Jenkins job that will update the Tomcat configuration on my virtual server whenever an updated configuration exists in source control. As soon as I create the job and hit the save button, its details will automatically be checked into source control thanks to the SCM Sync Plugin. The new job will be called "UAT_Update_Env" and its logical steps are going to be:

1) check Subversion repositories for changes and trigger the job when an update is available
2) SSH into the virtual server
3) update Tomcat6 configuration directories
4) restart Tomcat6 service
5) test configuration changes and fail the job if the test is unsuccessful

In order to SSH into the virtual server from a non-interactive session, I need first to add the virtual server's fingerprint to my local known hosts. I can do this by running an SSH session from the terminal on my laptop. On the virtual server I need to set up a user that will be dedicated to continuous delivery operations, and give this user some elevated privileges because it must be able to update the tomcat configuration and restart tomcat. I have chosen a user called "contdel".

laptop$ ssh contdel@192.168.56.2 pwd
The authenticity of host '192.168.56.2 (192.168.56.2)' can't be established.
ECDSA key fingerprint is 91:b2:ec:f9:15:c2:ac:cd:e2:01:d7:23:11:e0:17:db.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.56.2' (ECDSA) to the list of known hosts.
contdel@192.168.56.2's password: 
/home/contdel

In order to avoid interactive password prompts during the execution of the automated job, I choose to use private/public key authentication with SSH, so I generate the key on the virtual server and scp it to my laptop so that is visible to Jenkins. I could simply store it in Subversion, which is ok for the purposes of writing this series, but in a real production scenario I wouldn't do that.

There is one more thing I need to do on the virtual server, and it's to set up the correct access on the configuration files that I will update through automation and the restart script. I have already set up the user "contdel" on the virtual server, which is in the sudoers list. The permissions on the Tomcat configuration folder are set so that the owner (root) has read/write/execute rights, the group (root) has read/execute rights, and everyone else has read/execute rights.

UAT$ ls -lsah /etc/tomcat6
total 100K
4.0K drwxr-xr-x   5 root root    4.0K May  8 22:18 .
4.0K drwxr-xr-x  94 root root     12K May 20 22:30 ..
4.0K drwxrwxr-x   4 root tomcat6 4.0K May  8 22:18 Catalina
4.0K -rw-r--r--   1 root tomcat6 4.0K Jan 11 02:24 catalina.properties
4.0K -rw-r--r--   1 root tomcat6 1.4K Aug  5  2007 context.xml
4.0K -rw-r--r--   1 root tomcat6 2.4K Dec 13  2011 logging.properties
4.0K drwxr-xr-x   3 root tomcat6 4.0K May  8 22:18 policy.d
8.0K -rw-r--r--   1 root tomcat6 6.6K Jan 11 02:24 server.xml
4.0K drwxr-xr-x   6 root root    4.0K May  8 22:18 .svn
4.0K -rw-r-----   1 root tomcat6 1.5K Nov  4  2010 tomcat-users.xml
52K -rw-r--r--   1 root tomcat6  52K Nov 11  2011 web.xml

As it is, I still need sudo to do an svn update, which is fine from an interactive terminal, but it wouldn't work from a non-interactive Jenkins ssh session. If I did that, I would get an error similar to this:

sudo: no tty present and no askpass program specified
Sorry, try again.

This happens because the sudo command prompts for the user's password, which is obviously not going to work in a non-interactive session. What I can do is change the sudoers configuration to allow the user contdel to restart tomcat using sudo without a password prompt. The instructions on how to do so are on the Ubuntu help site. In the latest version of Ubuntu, the sudoers file will automatically include other configuration files stored in /etc/sudoers.d/ so I can avoid editing /etc/sudoers (which is a good thing) and add my changes to /etc/sudoers.d/contdel, so if I happen to mess up a directive I can easily revert back by removing the new config file and try again.

UAT$ sudo visudo -f /etc/sudoers.d/contdel
...
# Allow user contdel to restart tomcat via sudo without a password prompt
contdel ALL=(ALL:ALL) NOPASSWD:/etc/init.d/tomcat6
...

laptop$ ssh contdel@192.168.56.2 sudo /etc/init.d/tomcat6 restart
contdel@192.168.56.2's password: 
* Stopping Tomcat servlet engine tomcat6
...done.
* Starting Tomcat servlet engine tomcat6
...done.

Note that the password prompt comes from the local ssh command, not from the remote sudo command.

I can make it a little more secure by doing two things:

Restrict the sudoers directive for contdel so that it only applies when the command comes from the local network.
Use private/public key authentication for user contdel instead of username/password. This is particularly useful for Jenkins configurations that might or might not expose the password in the logs (or anywhere else).

However, I am still more interested in getting the update job going, so I'll go ahead and create the UAT_Update_Env job. In my previous post I set up the directory structure in source control that will hold all the relevant files in my project: not only the application code, but also all configuration files for the environment and the database script. The environment configuration files are in $SVN_ROOT/envsetup/[environmentID], which for UAT means $SVN_ROOT/envsetup/UAT. This job will therefore look for source control changes in svn://192.168.56.1/mywebapp/trunk/envsetup/UAT every five minutes, and if any changes are detected it will apply them via SSH to the UAT virtual server.

In terms of how the commands will actually be executed, I have two equally viable options:

I tell Jenkins to open a local shell and execute remote commands on UAT via SSH.
I tell Jenkins to start a slave on UAT that will execute shell commands locally

Just to keep things simple at this point in time, I'll go for the second option and use the SSH Slaves plugin that comes with the latest Jenkins "out of the box". I therefore need to create a new Jenkins slave called "UAT" that will run on my virtual server. Under the hood, Jenkins will connect to my virtual server via SSH, upload the slave configuration and binaries, and launch the slave process on the virtual server. When I set up my job in Jenkins, I will configure it to run only on the newly configured slave, and by so doing all commands and script will be executed by the slave on the virtual server. The root Jenkins directory on the new node will receive all files from the Jenkins master. These files will change often and after a job gets executed a number of times they can build up fairly quickly. I don't want to spend any effort cleaning them up regularly, so I'll just use /tmp as the root Jenkins directory. All files in there will disappear after each reboot.

The UAT_Update_Env job has the following characteristics.

The job is restricted to run onthe "UAT" node only.
The job monitors the configuration files in Subversion for changes every 5 minutes.
The job executes svn update /etc/tomcat6 followed by sudo /etc/init.d/tomcat6 restart.

Running the job verifies that it's all good.

Started by user anonymous
Building remotely on UAT in workspace /tmp/jenkins_slave/workspace/UAT_Update_Env
Cleaning local Directory .
Checking out svn://192.168.56.1/mywebapp/trunk/envsetup/UAT at revision '2013-05-23T16:59:19.322 +1000'
At revision 17
no change for svn://192.168.56.1/mywebapp/trunk/envsetup/UAT since the previous build
[UAT_Update_Env] $ /bin/sh -xe /tmp/hudson603902310922720127.sh
+ svn update /etc/tomcat6
At revision 17.
+ sudo /etc/init.d/tomcat6 restart
* Stopping Tomcat servlet engine tomcat6
...done.
* Starting Tomcat servlet engine tomcat6
...done.
Finished: SUCCESS

In order to test that Tomcat is actually working, I have to fire an HTTP request to the Tomcat server and check that it doesn't spit out an error. To do this I create a new Jenkins job called UAT_Verify_Env that uses curl to connect to the virtual server on port 8080. If a connection error occurs, curl will return an error and the job will fail. Since I am interested in verifying a successful connection and not in the actual output of the curl command, I can redirect the output to /dev/null. The UAT_Verify_Env job therefore executes one simple shell command:

curl http://192.168.56.2:8080 -o /dev/null

This job will be executed on the Jenkins master, not on the UAT slave, in order to verify external connectivity within the virtual network. Running this job on the UAT slave will only verify connectivity to the local network adapter.

Now I can test the full cycle: check out the tomcat configuration to a local workspace on my laptop, then change the HTTP connector port in server.xml, commit the changes, wait for Jenkins to figure out there are modifications in the source repository and fire the update job, then wait for the job to complete and use curl to check that tomcat is actually now listening on the new port. If I change the port to 8081 I will see the job UAT_Verify_Env fail, which is a good thing because it will prove that I have a way to quickly feed back a wrong environment configuration.

Started by user anonymous
Building on master in workspace /var/local/jenkins/jobs/UAT_Verify_Env/workspace
[workspace] $ /bin/sh -xe /tmp/tomcat6-tomcat6-tmp/hudson1161186187774233720.sh
+ curl http://192.168.56.2:8080 -o /dev/null
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed

  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
curl: (7) couldn't connect to host
Build step 'Execute shell' marked build as failure
Finished: FAILURE

Changing the port back to 8080 and checking in the changes to source control will get everything back on a happy path.

Started by user anonymous
Building on master in workspace /var/local/jenkins/jobs/UAT_Verify_Env/workspace
[workspace] $ /bin/sh -xe /tmp/tomcat6-tomcat6-tmp/hudson2858331979742011098.sh
+ curl http://192.168.56.2:8081 -o /dev/null
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed

  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100  1887  100  1887    0     0   260k      0 --:--:-- --:--:-- --:--:--  921k
Finished: SUCCESS

In a similar fashion as for Tomcat, I can extend this process to also update the MySQL configuration. I will skip the detailed description here, but it follows exactly the same principles as above: make sure that user contdel can perform an svn update on the MySQL configuration folders and files, allow user contdel to restart MySQL via sudo without a password prompt, and add the relevant shell commands to the existing job configuration, then amend the UAT_Update_Env and UAT_Verify_Env jobs in Jenkins to account for canges in MySQL configuration.

Trying Continuous Delivery - Part 1

2013-05-13T22:34:00.001+10:00

Please note: I am making this stuff up as I go along, so I may have to update each post at a later stage to reflect some changes that I think might make things easier to manage.

In a previous post I introduced this series looking at continuous delivery from a practical standpoint, taking a simple web application and automating its lifecycle. This post outlines the initial setup of the continuous delivery system. These are the steps I will follow:

Install VirtualBox, Subversion and Tomcat on my laptop
Prepare Ubuntu Server virtual machine with Subversion and Tomcat
Set up SVN repository and user access list on my laptop
SVN checkin Tomcat settings from virtual server
SVN checkout Tomcat settings onto my laptop
SVN checkin modified Tomcat settings from my laptop
SVN update Tomcat settings on the virtual server
Restart Tomcat on the virtual server and verify changes

Installing VirtualBox and Subversion on my Ubuntu laptop is straightforward with apt-get,
but the Ubuntu Software Centre makes it even easier.

I can then prepare the virtual server by downloading the relevant ISO image and hooking it up to the virtual DVD of a new virtual machine. After installing Ubuntu Server I have a new environment ready to be configured as my integration box.

By default, the virtual machine has a NAT network adapter and later I will configure it to have a host-only connection with a static IP address to my new virtual server, so I can work with it also when I'm not connected to my home network. A host-only connection is also useful to simulate environments that wouldn't normally be connected to the Internet and that's ultimately the kind of adapter that I want to be working with. Before I do that, I need to install/update the relevant tools on the virtual machine: SSH Server, Subversion, Tomcat6, and MySQL, plus a few basic packages to facilitate administration and remote view.

VM$ sudo apt-get update
VM$ sudo apt-get install openssh-server subversion tomcat6 mysql-server X.org zerofree make gcc linux-headers-$(uname -r)

After I got my baseline software on the virtual machine I can create a host-only adapter in VirtualBox (File / Preferences / Network), so I will have two adapters: one NAT adapter (the default) and one host-only adapter.
After all updates are installed, I won't need the NAT adapter any more (at least until the next major package upgrade), so I can either disable it in VirtualBox, or disconnect it (untick the "Cable Connected" check box in the VM settings) without actually removing it altogether. If I ever need to install a new package or perform a major upgrade, I just re-enable the NAT adapter very easily and then disable it right away.

I need my host-only adapter to have a fixed IP address (no DHCP). The reason for using fixed IP addresses is twofold: firstly, because I want my continuous delivery scripts to be simple and deterministic without having to install a name server/DNS just for this system; and secondly, because a production-like infrastructure would most likely use fixed/reserved IP addresses anyway. I don't want to install DNS or any other name resolution service, and I only need to set up just a few virtual machines, so I'll just maintain all hostnames and addresses in /etc/hosts.

127.0.0.1       localhost
192.168.56.1    VM-host      # The VM host
192.168.56.2    UbuntuSRV    # The baseline VM
192.168.56.3    Integration  # The integration VM
192.168.56.4    UAT          # The user acceptance VM
192.168.56.5    PROD         # The production VM

I decide to assign IP address 192.168.56.1/24 to the host-only adapter in VirtualBox, for no particular reason other
than because it's the default address that VirtualBox is using for me. It follows that the IP address on my virtual
server will have to be in the format 192.168.56.xxx in order to communicate with the host (my laptop).

Change the interface configuration on the VM.

VM$ sudo vi /etc/network/interfaces

...
auto eth0
iface eth0 inet static
address 192.168.56.2
netmask 255.255.255.0
gateway 192.168.56.1
...

Restart the network interface on the VM.

VM$ sudo ifdown eth0
VM$ sudo ifup eth0
ssh stop/waiting
ssh start/running, process 1234

Test communication from virtual machine to laptop host.

VM$ ping -c 3 VM-host
PING VM-host (192.168.56.1) 56(84) bytes of data.
64 bytes from 192.168.56.1: icmp_req=1 ttl=64 time=0.828 ms
64 bytes from 192.168.56.1: icmp_req=2 ttl=64 time=1.03 ms
64 bytes from 192.168.56.1: icmp_req=3 ttl=64 time=1.893 ms

--- VM-host ping statistics ---
3 packets trasmitted, 3 received, 0% packet loss, time 2003ms
rtt min/avg/max/mdev = 0.828/0.919/1.037/0.090 ms

laptop$ ping -c 3 UbuntuSRV
PING UbuntuSRV (192.168.56.2) 56(84) bytes of data.
64 bytes from 192.168.56.2: icmp_req=1 ttl=64 time=1.54 ms
64 bytes from 192.168.56.2: icmp_req=2 ttl=64 time=0.760 ms
64 bytes from 192.168.56.2: icmp_req=3 ttl=64 time=0.737 ms

--- UbuntuSRV ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2000ms
rtt min/avg/max/mdev = 0.737/1.012/1.540/0.374 ms

Now we can use the NAT adapter for internect connections, and the host-only adapter for connections to 192.168.56.xxx addresses , so the routing table needs to reflect this separation.

VM$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.56.1    0.0.0.0         UG    100    0        0 eth1
10.0.2.0        0.0.0.0         255.255.255.0   U     0      0        0 eth0
192.168.56.0    0.0.0.0         255.255.255.0   U     0      0        0 eth1

VM$ ping -c 3 www.google.com
PING www.google.com (74.125.237.178) 56(84) bytes of data.

--- www.google.com ping statistics ---
3 packets transmitted, 0 received, 100% packet loss, time 2014ms

It looks like the default route is through the host-only adapter, and no route leads to the Internet. I need to change that, so I'm going to use the VirtualBox NAT adapter 10.0.2.2 as a gateway for the default route. This way I can have a host-only connection and a NAT connection, both working, and with Internet access.
When I want a strict host-only connection, all I have to do is untick the "Cable Connected" box in the VirtualBox settings for my virtual server's NAT adapter.

VM$ sudo route del default
VM$ sudo route add default gw 10.0.2.2 dev eth0
VM$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         10.0.2.2        0.0.0.0         UG    100    0        0 eth1
10.0.2.0        0.0.0.0         255.255.255.0   U     0      0        0 eth0
192.168.56.0    0.0.0.0         255.255.255.0   U     0      0        0 eth1

VM$ ping -c 3 www.google.com
PING www.google.com (74.125.237.178) 56(84) bytes of data.
64 bytes from 74.125.237.178: icmp_req=1 ttl=64 time=19.9 ms
64 bytes from 74.125.237.178: icmp_req=2 ttl=64 time=10.7 ms
64 bytes from 74.125.237.178: icmp_req=3 ttl=64 time=12.6 ms

VM$ ping -c 3 VM-host
PING VM-host (192.168.56.1) 56(84) bytes of data.
64 bytes from 192.168.56.1: icmp_req=1 ttl=64 time=0.834 ms
64 bytes from 192.168.56.1: icmp_req=2 ttl=64 time=1.11 ms
64 bytes from 192.168.56.1: icmp_req=3 ttl=64 time=1.876 ms

Looks good, so I'll just make this route persistent and move on.

VM$ sudo vi /etc/network/interfaces

...
...
up route add default gw 10.0.2.2 dev eth0
...
...

VM$ sudo service networking restart

So far so good. Let's get Subversion running and test connectivity from the virtual machine. We'll need a local repository first of all, then run the standalone Subversion server listening on the adapter used for the
VirtualBox host-only connection.

laptop$ mkdir -p ~/svnrepo/mywebapp
laptop$ svnadmin create ~/svnrepo/mywebapp
laptop$ svnserve -d -r ~/svnrepo --foreground --log-file ~/svnserve.log --listen-host 192.168.56.1

VM$ svn info svn://VM-host/mywebapp
Path: mywebapp
URL: svn://VM-host/mywebapp
Repository Root: svn://VM-host/mywebapp
Repository UUID: cbcda313-59ce-438c-844d-f6a9db7a4d30
Revision: 0
Node Kind: directory
Last Changed Rev: 0
Last Changed Date: 2013-05-13 12:57:36 +1000 (Mon, 13 May 2013)

It looks like I have a good baseline virtual server that I can use as a template to create my other virtual environment. Let's start with the Integration environment (INT). I only have to clone the baseline VM in VirtualBox using the 'linked clone' option, also making sure I reinitialise the MAC address of all network cards.

What I want to do now is to import the existing Tomcat configuration from the INT virtual machine into Subversion. This way I will be able to control any modifications to these settings from my development laptop. When I check in new versions of the settings, I will shut down the relevant services on the virtual machine, update the settings' working copies, and restart the services in order to pick up the new settings. In fact, I can even manage these changes from Eclipse, together with the application source code. It is easy to create an empty folder structure in Eclipse on my laptop host and then commit it to Subversion. I can then checkout the relevant folders in my virtual machine, svn add the relevant configuration, and check it all in.

INT$ svn import /etc/tomcat6 svn://VM-host/mywebapp/trunk/envsetup/INT/tomcat6 -m "Initial import for tomcat6 config"
INT$ sudo svn co svn://VM-host/mywebapp/trunk/envsetup/INT/tomcat6 /etc/tomcat6 --force

I need to sudo these commands because these directories are usually owned by root, and adding them to Subversion is an operation that needs write access because it will automatically generate some synchronisation metadata files and folders in the working copy directory. Back on the laptop host, I now need to update the Eclipse project and I will be able to manage configuration changes from there.

To test that this arrangement actually works, I can use Eclipse to change the Tomcat HTTP port on the guest virtual machine. I'll change it back afterwards.

[server.xml (snippet)]
...
    <!-- changed from port 8080 to port 8081 -->
    <Connector port="8081" protocol="HTTP/1.1"
               connectionTimeout="20000"
               URIEncoding="UTF-8"
               redirectPort="8443" />
...


INT$ sudo /etc/init.d/tomcat6 stop
 * Stopping Tomcat servlet engine tomcat6 [OK]

INT$ sudo svn update /etc/tomcat6
U   /etc/tomcat6/server.xml
Updated to revision 6

INT$ sudo /etc/init.d/tomcat6 start
 * Starting Tomcat servlet engine tomcat6 [OK]

Now pointing my browser from the laptop host to the guest address http://Integration:8081 shows the Tomcat welcome page.

This means that now I can successfully drive any Tomcat configuration changes from my development environment.
Also, it means that I can safely revert to any previous revision of the Tomcat configuration if something goes wrong.
In fact, I'll just test that now.

[in my workspace folder]
laptop$ svn merge -r COMMITTED:PREV .
--- Reverse-merging r16 into '.':
U    envsetup/INT/tomcat6/server.xml

laptop$ svn commit -m "Reverting previous commit"
--- Reverse-merging r16 into '.':
U    envsetup/INT/tomcat6/server.xml

INT$ sudo svn update /etc/tomcat6
U    /etc/tomcat6/server.xml
Updated to revision 17.

INT$ sudo /etc/init.d/tomcat6 restart
 * Stopping Tomcat servlet engine tomcat6 [OK]
 * Starting Tomcat servlet engine tomcat6 [OK]

Now pointing my browser from the laptop host to the guest address http://Integration:8081 spits out a browser connection error, but http://Integration:8080 shows the Tomcat welcome page as expected.

To recap, this is what I have so far:

a physical host (my laptop) with Tomcat, Eclipse, and VirtualBox

a Subversion server running on the physical host, using a local directory as a repository

a virtual server (my baseline) with Tomcat, Subversion and MySQL, connected with the physical host using a host-only adapter

a virtual server (my integration server) cloned from my baseline, with its Tomcat configuration in the Subversion repository

and this is what I can do with the current setup:

change the Tomcat configuration of the virtual server from my development IDE on the physical host
easily pick up the latest Tomcat configuration changes on the virtual server
easily revert to any previous revision of the Tomcat configurations

Next post will introduce the element of automation in configuration changes.

Continuous Delivery in Practice - Introduction

2013-04-21T22:57:00.002+10:00

I am a big fan of automation, and this passion of mine has taken me to become also a big fan of Continuous Delivery. I may have not searched hard enough, but I can't seem to come across some practical examples of Continuous Delivery, so I decided to make my own for two reasons:

to help myself in learning more about the pratical applications of Continuous Delivery
to hopefully help others in doing the same

So this post is to start a multipart series on the practical implementation of Continuous Delivery for a very simple web application. I will not write much about the application itself because my main focus is to put together and describe the infrastructure and the mechanisms that keep the system always in a releasable state.

It is worth noting that Continuous Delivery does not imply Continuous Release. The idea is to make sure that the system as a whole (not just the application) is always in a releasable state. This way, a release becomes purely a business task that doesn't require lots of coordination efforts with a number of technical teams.

This post series is going to be loosely based on the book "Continuous Delivery" by Jez Humble and David Farley, which is (needless to say) a must read for anyone interested in this topic. The book outlines some fundamental principles of Continuous Delivery:

Create a repetable, reliable process for releasing software
Automate (almost) everything
Keep everything in version control
If it hurts, do it more frequently and bring the pain forward
Build quality in, right from the start
Done means released
Everybody is responsible for the delivery process
Continuous improvement

I will explicitly refer to most of these principles as this post series evolves. It is worth noting that, because of principle n.3, I will make right away a critical decision: if it can't be source-controlled, it won't be part of my technology stack. In other words, I will only use tools/packages/platforms driven by (mostly) text-based configuration (properties files, xml files, etc).

In the first post I will be setting up some virtual environments right from the start before any code is written, and by driving environment changes through source control.

Finally, the obligatory disclaimer:
Please note: I am making this stuff up as I go along, so I may have to update each post at a later stage to reflect some changes that I think might make things easier to manage.

Useful Online Help

2013-04-20T15:17:00.001+10:00

The point of this short post is that including some help tool with your product is not enough. Help tools are supposed to be helpful, and in order to be helpful it must be easily understood. I think that's common sense.

So why, oh, why do so many vendors, even the big names, avoid investing that little bit extra effort in proof-reading instructions and documentation? This is a classic example. The equipment is a Cisco EPC3925 EuroDocsis 3.0 2-PORT Voice Gateway.

"IP Flood Detection is hacker intrusion method when massive amount of packets are send to the networking equipment with a purpose to overwhelm it.This can expose weaknesses or cause failures.Enabling this future is essential part if intrusion prevention."

This is just one example. The rest of the documentation runs along the same standards.

I mean... really... Cisco... come on... Yes, I can understand what the statement actually means, but is this English? I can appreciate that translation into English from other languages might not be straightforward, I know, that's fine, but are you really unable to find one... ONE... English native-like speaker that can proof-read this stuff? I'm pretty sure you can afford it.

Ossessione

2013-01-09T19:50:00.002+11:00

fredde stelle
di una tremante sera
mi parlano
di cieli gialli e tempeste eterne
nell'ombra di un tetto di luce

mura che abbagliano
di una tenebra infinita
dentro scatole viventi che respirano bugie
nelle strade dell'uomo senza occhi

un bastone fiammeggiante
una carta dipinta di lacrime
un gioco che brucia il mondo
un mondo che brucia me

lasciamoci sfinire da noi stessi

O-S-S-E-S-S-I-O-N-E

The relationship between language and gender and the implications for language planning.

2012-06-29T00:00:00.000+10:00

The relationship between language and gender and the implications for language planning.

This essay will discuss the relationship between language and gender, and argue that some of the differences between men’s speech and women’s speech contribute to build and maintain a power imbalance between the two sexes. A summary will first be given of some generalizations about gender-language association, followed by an outline of the main sociolinguistic approaches used in the study of gender-related language variations. Some consideration will then be given to the influence of language on establishing and maintaining social structures and social divides, with some implications for language planning.

One of the study areas of Sociolinguistics is articulated around language varieties that are associated with one gender or the other. Since their distinguishing element is the association with gender, these varieties are also known as genderlects and their characteristics vary across countries, cultures, generations, religions, and social groups. For example, speech patterns associated with male western-European youth cultures are different from those associated with male eastern-European youth cultures, or male western-European adult cultures. Commonly, there are numerous stereotypes associated with male and female speech that give rise to generalizations about men and women, like the perception that women are more empathetic and polite while men are more factual and “dry”.

Initial interest in gender-related speech patterns arose in the 1960s, when Labov published a study on the social motivation of sound changes (1963) and another one on the social stratification of language (1966). The objective of Labov’s studies was to examine the contexts in which certain phonological patterns would apply in relation to a set of social variables, among which were status, ethnic group, and sex. Among his findings there was a tendency of women to adopt standard variants and to “follow an extreme pattern of stylistic variation” (1966, p. 312), or to “hypercorrect”, in an effort to emulate other linguistic patterns that are perceived to be somewhat superior or set the benchmark. The systematic study of genderlects, however, seems to have started in the early 1970s, when Lakoff published a study on the frequency in which a number of linguistic features occurred in women’s speech compared to men’s speech (1973). Lakoff’s approach was labelled the “deficit approach”, because it alleged that women’s speech was characterized by “uncertainty” and “lack of confidence on the part of women” (Fromkin et al. 2011, p. 449). This view was supported by the notion (at the time) that male speech was considered to represent the unmarked standard form; therefore any variation from the unmarked form (like the variation brought by female speech) was - by definition - a marked form. As a result, with the male speech setting the benchmark by convention, any variation from it would automatically be perceived somewhat inferior.

Moving in a similar direction was the “dominance approach”, according to which male speech was dominant over the subordinate female speech, probably as a result of traditional western patriarchal social structures (Spender, 1985). Even though the dominance approach does not overtly assume female genderlects to be substandard or inadequate, it still reflects a concentration of power and authority in male speech, placing male society in a status of supremacy.

The “difference approach” removes the ideas of “better” and “dominant” and looks at male and female genderlects as manifestations of two different sub-cultures: there is no differentiation in terms of power, but there is differentiation in terms of cultural contexts. Tannen (1990) looked at genderlect differences from a pragmatic point of view, looking at meta-messages: what is really being communicated as opposed to what is actually being said. For example, an offer for help might convey a meta-message that the person offering help is more capable and competent than the person being helped. This way, meta-messages can cause the listener to perceive either a difference or an equality in status between the conversation participants. Tannen’s findings show different areas of differentiation between male and female speech. For example, Tannen claims that women tend to focus more on intimacy and connection with their interlocutors, while men tend to shape their conversation around meta-messages of competition and independence. Also, men tend to be more comfortable than women when talking in public, while women are generally more comfortable than men when talking in private settings.

Cameron (2007) argues that historical approaches to the study of genderlects may be incomplete, especially with reference to both the dominance approach and the difference approach. One aspect of Cameron’s argument is that male genderlects are usually considered to be unmarked dialect forms, whilst female genderlects by reflection become the deviant forms. However, this is just an artificial benchmark, since there is no evidence to suggest that it could not be the reverse: female genderlects providing the unmarked form and male genderlects being deviant. Another aspect of the argument against the difference approach is that, although it tries to offer a more egalitarian or levelling perspective on genderlects by focusing on contextual differences rather than power and submission, it seems to miss the idea that those differences are still actual manifestations of relative two-way dominance. For example, conversational dominance is not just about the behaviour of certain participants of the conversation in the establishment of hierarchical prestige: it is also about the conscious choice of the other participants to allow that to happen. In general, Cameron argues, there seems to be no evidence to support the relationship between the roles of men and women in society, and their language use.

More recently, the social constructionist approach has developed a dynamic study of language and genders, following the principle that language is an expression of culture and, as a result, social constructs are directly linked to speech constructs. Speech constructs, however, go beyond being simply a projected expression of an underlying “fixed” social structure and become tools that the participants actively use to dynamically shape and maintain the social structure (Zimmermann and West, 1975). The use of different language varieties across specific social structures was examined in detail by Eckert and McConnell-Ginet (1999), who introduced the concept of Communities of Practice, in which groups of people are connected by common tasks or projects and over time construct a set of shared practices. As such communities are established and maintained, linguistic patterns and speech strategies are also established and maintained therein. When single-sex communities of practice come to exist, whether by coincidence or by some form of social or institutional barrier, it is easy to mistake for gender identity the linguistic identity that those communities build and develop for themselves. In other words, the association between a language form and a community of practice whose member just happen coincidentally to belong to the same sex, over time can transform into an association between that language form and a specific gender, according to some kind of social projection where community of practice and gender are two faces of the same sociolinguistic coin.

As theories of language and gender developed, attention seems to have shifted away from physical and biological variables towards social, cultural, and historical variables. The deficit approach considered sex to be one of the variables that shaped and influenced language patterns, while the dynamic approach completely reverted the cause-effect relationship and considered linguistic variables to shape and influence the expression of gender.

In general, modern approaches look at linguistic patterns and conversational styles, and some generalizations have become popularized with various degrees of accuracy. For example, minimal responses are paralinguistic features in the form of vocal expressions that can be used for different purposes by men (showing agreement) and women (building collaborative discourse). Questioning is usually a strategy adopted by men to request information and without further motive; it is however adopted by women to build participation, elicit contributions, and generally engage in collaborative discourse. Disclosure of personal information is perceived by men as a sign of weakness and strongly avoided, but it is a subtle strategy used by women to connect and build intimacy and trust with other discourse participants. Attentiveness and listening are two important factors in the construction of meaning, because meaning is shaped in the mind of the listener thanks also to other types of input than just what is being said. Women’s tendency to build intimacy and trust makes them also “good listeners”, while men’s tendency to build up status through turn dominance makes them “bad listeners”.

While all the above strategies and tendencies may be verifiable in certain contexts and cultures, there seems to be no consensus on their universality. There appears to be, however, agreement on the notion that gender is one of the identity traits expressed through language. Language is used by individuals not only to negotiate meaning but also to negotiate identity, so gender is something that people “do” or construct through language. If it were true that standard forms were perceived as being more prestigious and desirable than non-standard forms, then there should be very little motivation for individuals to keep using non-standard forms. However, ordinary life experiences present strong evidence not only of the existence of numerous social groups that use non-standard forms, but also of their conscious effort to keep those forms instead of aiming at the adoption of standard forms. According to Labov (1966), this is due to group members perceiving and receiving covert prestige in the establishment and maintenance of group identity, instead of pursuing more standardized dialect variants.

There are two main areas of concern about genderlects that have emerged thus far in this essay: the first one pertains to their initial development (how genderlects came to exist and separate in the first place), and the second concerns their preservation (how or why they still exist in modern societies). In terms of their initial development, genderlects may find the roots of their differentiation in the establishment and perpetuated existence of single-sex communities of practice in the past. For example, in many societies war used to be an activity reserved to men alone, while women would engage in “safer” activities like socializing and nurturing, and so it was for many centuries. It seems therefore logical to suppose that most dialects that developed in the communities of practice directly related to war activities eventually became male genderlects. With time, the establishment of numerous single-sex communities of practice contributed to the reinforcement of genderlects (and gender) differentiation in what Eckert and McConnell-Ginet (1999) call “institutionalization of gender” (p. 189). In terms of genderlects preservation, Labov’s explanation that group identity is more prestigious than the adoption standard forms of language seems to be very logical. It is important to stress that individuals can and do belong to multiple communities of practice, and that is why group identity is not simply adopted or built unilaterally: it is negotiated according to the prevailing context. Following a social constructionist view, it is important to consider the notion that humans participate in the construction of a dynamic society with multiple aspects or facets, and the construction of individual identity and group identity is part of the process. Since social facets are not natural constructs they need to be continuously maintained, and humans do this through the institutionalization of social phenomena and the construction of traditions which, when applied to single-sex communities of practice, serve to also maintain gender separation and relative dominance.

There is also a third area of concern about genderlect differentiation: the rise of discriminatory attitudes towards sex (as a biological trait) and gender (as a component of identity). Linguistic discrimination happens when people are treated differently based on the language they use. If certain linguistic forms are distinctly associated with one gender or the other, then linguistic discrimination can become a form of sex discrimination. The preservation of genderlects as instruments used to assert individual identities therefore may become (perhaps thanks to the popular “law of unintended consequences”) a mechanism to also preserve sex discrimination. Also, if the standard form of a language has a bias towards the use of male-specific or female-specific lexicon and constructs, this may well have an influence on the perception that one gender has a higher prestige than the other, shaping social attitudes accordingly and maintaining unequal states in society. For example, the Italian language is gender-biased in many ways, one of which is that there is no neutral grammatical gender, so all nouns are either masculine or feminine, and pronouns in a sentence are assumed to refer to masculine entities unless specifically intended otherwise. In modern societies there seems to be widespread acceptance of gender-discriminatory constructs even in languages that are not perceived to be gender-biased. For example, the English language is grammatically gender-unbiased (nouns can be masculine, feminine, or neuter), but it is not uncommon to find tiles like “stewardess”, “fireman”, or “waitress” on job adverts in English-speaking countries, maintaining the historical gender connotations of various communities of practice.

Wardhaugh’s views on the development and preservation of gender-specific constructs are that

“[...] men’s and women’s speech differ because boys and girls are brought up differently and men and women often fill different roles in society. Moreover, most men and women know this and behave accordingly” (2006, p. 354).

In other words, there seems to be a strong traditional attitude in the sense that the social development of new generations has always been accomplished in a certain gender-biased way, and unless something is done to disrupt this attitudinal inertia it will endure in exactly the same way. Wardhaugh continues by proposing that less sexist child-rearing practices and role differentiation would reflect into less sexist language practices and bring a “greater freedom of choice”.

According to Wardhaugh, language planning is “an attempt to interfere deliberately with a language or one of its varieties” (p. 379) and there are different ways in which it operates. Corpus planning is a form of structural engineering for a language: it involves processes that are aimed at altering linguistic constructs through graphization (the prescription of orthographic conventions), standardization (the elevation to standard form of one variety over the others) and modernization (the extension of a variety to meet new functions). Status planning aims at influencing the perceived status of a language variety with respect to other varieties, by means of association with specific functional domains, so that the language variety acquires the same status as the functional domain in which it is commonly used. It is perhaps thanks to a combination of both, channeled through the education system and the media, that progress can be made in the mitigation and control of sex discrimination.

This is in some ways an application of the Sapir-Whorf hypothesis of linguistic relativity: if the language we use influences thought and society, and if linguistic constructs determine cognitive constructs, then any changes in the language we use will determine some changes also in our social attitudes, so by carefully crafting a series of structural linguistic alterations around sexist dialectal forms we should be able to induce favourable changes in society’s sexist attitudes towards a higher degree of gender equality. If that is the case, then these principles can be used by language planners in the formulation of appropriate policies to reduce or even eliminate sex discrimination in society.

Marco Scata

References

Cameron, D. (2007). The Myth of Mars and Venus. Oxford: Oxford University Press.

Eckert, P., and McConnell-Ginet, S. (1999). New generalizations and explanations in language and gender research, Language in Society, 28 (2), 185-201. Cambridge: Cambridge University Press

Fromkin, V. et al. (2011). An Introduction to Language (9th ed, international). Wadsworth: Cengage Learning.

Kaplan, B., & Baldauf, B. (1997). A framework for planning: who does what to whom?. In Language planning from practice to theory (pp. 28-58). Philadelphia, PA: Multilingual Matters.

Labov, W. (1963). The social motivation of a sound change. Word 19, 273-309

Labov, W. (1966). The social stratification of English in New York city. Washington, D.C.: Center for Applied Linguistics.

Lakoff, R. (1973). Language and woman's place. Language in Society, 2 (1), 45-80. Cambridge: Cambridge University Press

Spender, D, (1985). Man made language. (2nd ed.) London: Routledge & Kegan

Tannen, D. (1990). You just don’t understand. Women and men in conversation. New York: William Morrow.

Wardhaugh, R. (2006). An introduction to sociolinguistics (6th ed.). Oxford: Blackwell Publishers.

Zimmermann, D.H., and West, C. (1975). “Sex roles, interruptions and silences in conversation”. In Thorne, B. and Henly, N. (1975). Language and Sex: Difference and Dominance, 105-29. Rowley, Massachusetts: Newbury.

Boken design series: Gamevil's Fantasy War

2012-06-02T20:18:00.000+10:00

With this post I will start a series dedicated to broken design. What's broken design? It's about things that we use that are fundamentally flawed. It's about stuff that seems obvious to some people but not to product designers.
I will start the series with a post about a game for the iPhone that I recently tried. The game is called Fantasy War, produced by Gamevil, and can be found on the Gamevil website and on iTunes.
The purpose of the game is to become the leader of a fantasy realm. You can be human, orc or elf, and you progress through the game by completing some quests, battling the forces of evil in some dungeon, and waging war against other players. As you accumulate experience and resources, you can improve the infrastructure (gold mine and lumber mill), learn new skills (cloth making, leatherworking, etc), upgrade your weapons, and hire stronger and more powerful armies. The graphics resembles some 1990s arcade games, but it's still not bad for a mobile game. The rules are fairly quick to learn without explicit instructions and the level progression gradually unlocks more interesting content. The developers make money selling "runestones", which allow you to do a lot more stuff and get really powerful armies.
Sounds ok, right? Well I actually like the game. It's very easy to play and the content is not bad at all. So where's the problem? What's the broken design?
Well, the problem is that this is not an iPhone game, or at least it's not meant to be. When you install the game, you actually install a simplified internet browser with little or no content. Every time you interact with the game, you actually navigate through a web page. All commands, all icons, all images, are just hyperlinks on a web page. Hang on, so where's the problem? I use internet all the time with my iPhone, and I have a lot of games on my iPhone that need an internet connection to work. No big deal. No, indeed, it wouldn't be a big deal... if the game wasn't so connection greedy! There is no content on the iPhone. Everything needs to be downloaded from the internet, including all the images (and there are a LOT of images!). In other words, this game assumes that it is running on a permanently connected device on broadband speeds... which is exactly the opposite of what an iPhone is. My user experience with this game goes something like this:

start the game
watch the rotating "loading..." icon for a few seconds
watch a dark screen behind the "loading..." icon
watch the text labels of the home screen appear behind the "loading..." icon
watch the graphic background appear behind the "loading..." icon
watch the images loading in chunks behind the "loading..." icon
home screen fully loaded
tap on any activity
watch the rotating "loading..." icon for a few seconds
repeat from point 3

In the end, I spend more time watching the rotating "loading..." icon that actually playing the game. Add to this the fact that there is no fault tolerance built in this simple browser, and you also get to build familiarity with the "check your internet connection" error, after which you can only shut down the game and start it again.
Also add to this the fact that dungeons are time limited (you need to kill the boss within 'N' minutes, or you have to wait for an hour or more before you can try again) and you can see how you can quickly build up frustration.
The cherry on the cake is that if something goes wrong with the game you get some Korean error message popping up, which is ok if you can read and understand Korean (I can't do either).
The verdict: broken design!
This is a basic architectural requirement for anything that is supposed to run on an iPhone: it must (please note, "must", not "should") be built for a seldom connected environment with less-than-broadband speeds. If that's not the case, then don't bother.

Quality Control

2012-05-05T21:10:00.000+10:00

There seems to (still) exist a great deal of confusion in many teams about the concept of continuous integration (CI).

The mighty Martin Fowler explains it in one of his seminal articles (http://martinfowler.com/articles/continuousIntegration.html)

Wikipedia defines CI as the principle of implementing "continuous process of applying quality control" (http://en.wikipedia.org/wiki/Continuous_integration)

Just googling up the term produces nearly 6 million references (http://www.google.com/search?hl=en&q=continuous+integration&btnG=Google+Search&meta=) so one might infer at least two things out of this:

1) that the topic is well covered

2) that the topic is very popular

Why, then, have I found it so difficult to find a proper implementation of continuous integration?

Perhaps it depends on what I mean by "proper implementation", so I thought about what I would really expect to receive from a "proper" CI implementation. In other words, what is the quantifiable value that a good CI process adds to my team?

My concept is very much in tune with the Wikipedia definition, in that CI is one of the many means to an end: quality control. The value of a CI process is in quality control, so it is useless if it does not deliver the means to check the quality of the deliverables.

Primal Noise

2012-03-18T13:01:00.001+11:00

You need to enable JavaScript to see this post.

This is what the first 1000 prime numbers look like when you plot them using their binary representation, one after the other. Are there fractal patterns in this image, like noise on a phone line? I don't know. Maybe I'll discuss it in another post.

This image is created by first translating each number in its binary string (e.g. decimal 53 to binary 110101), then converting each '1' into a little black square and each '0' into a blank space.

The image is produced using simple JavaScript scode. Have a look at the page source if you're interested. Search for 'var primes', 'function createRow' and 'function createTable'. I used jQuery to simplify it a little bit.

What's in a number?

2011-05-27T21:32:00.001+10:00

Imagine this discussion.

Developer 1: In the past week our code coverage raised from x% to y%

Developer 2: That's pretty good. There was is still quite a bit of dead code after the recent refactoring so I think we'll get to z% by next week.

Developer 3: I still think we should aim for 100%.

User/Analyst/Sponsor: What does that mean?

Developer 1: It shows how much of the whole code base we can actually test as part of our build process.

User/Analyst/Sponsor: Ok, and why is that important?

Developer 2: It's important to know how much is not covered.

User/Analyst/Sponsor: Oh, so you know how much more you have to work before you get to 100%

Developer 3: Well, not exactly. Our policy is to aim for z%

User/Analyst/Sponsor: Hmmm, and what's the use of z%? What does that mean to us?

Developers: What does it mean to you? Well it means that... hmm... that you know... it means... well... er...

That's not quite my direct experience, but I recently had to explain code coverage to non-coders and I realised how little thought some developers have put into the practical importance of code coverage outside the developers' domain.

I think most developers should be familiar with the concept of code coverage, which is simply the number of lines of code that get executed as part of the test suite expressed as a percentage of the total number of lines of code written. Full coverage (100%) means that my tests manage to execute (cover) all of my code. Less than full coverage means that there is some code that is not being tested. I'm not just talking about unit tests: I am also including integration tests and automated UI tests into the picture.

There have been countless debates on how much coverage is good coverage, including various tools and methodologies, so I won't go into a lot of detail here and I don't want to entertain anyone with yet another post on the miracles of test-driven development (TDD). The main concern here is that we cannot measure how "important" a line of code is with respect to another line of code. If we could, we would be able to come up with an "ideal" coverage target and be happy with that. Unfortunately in practice when I have anything less than full coverage I cannot tell whether the "uncovered" code is going to eventually bite me with a vengeance, or whether it will ever get noticed at all. It all depends on usage.

What's the meaning of an x% code coverage to me as a developer? In all practical terms, if it's less than 100%, then it means nothing. So either I strive for full coverage, or why should I bother? That is the basis upon which code coverage sometimes is ignored altogether, or is used only to produce colorful block charts for project status reports.

Now what does that mean to testers? Testers usually understand the concept of code coverage and many are wise enough to avoid taking code coverage as a measure of quality of deliverables. Why is that? Well, quite simply, my automated tests might well test 100% of my code base, but that doesn't mean they actually test the right thing in the correct way.

So what does code coverage means to me as a tester? In general terms, a code coverage of x% means that, for every new feature I add to the product, or every bug I fix, I have roughly an x% degree of confidence that I am not going to break existing features or resurrect old bugs (provided my tests actually test behavior - not just classes and methods - and that each new bug is reproduced with a test before it gets fixed).

But what's the meaning of it to users and analysts? When they see the regular progress report on the system being developed, what information does code coverage convey to them?

The meaning of code coverage to me as a user is actually more important than one might think. Roughly speaking, a code coverage of x% means that with every action I perform on the system, there is roughly a (1-x)% probability that something will go wrong.

To put it slightly differently (or perhaps more precisely), an x% code coverage means there is roughly an x% probability that my interaction with the system produces the expected result because that's what it was programmed to do. Conversely, there is roughly a (1-x)% probability that my interaction with the system produces the expected result by chance. The degree of criticality of the system then dictates the degree of acceptance or tolerance for failure (or tolerance to chance), which we can match against code coverage.

Paste di Mandorla (Almond Biscuits)

2010-12-12T23:00:00.000+11:00

Ingredients

2 egg whites
200g caster sugar
a few spoonfuls of icing sugar (for coating)
400g almond meal
1 teaspoon of almond essence
1 teaspoon of honey (preferably orange honey)
1 tablespoon of lemon juice
half a teaspoon of baking powder
half a teaspoon of sodium bicarbonate
1 teaspoon of vanilla paste
pinch of salt

Preparation

Whisk the egg whites until stiff
Add the lemon juice, the honey, the vanilla paste and the almond essence.
Whisk vigorously. The mixture will become much softer, but it should still be fluffy.
Add the caster sugar, the baking power, the sodium bicarbonate and the salt.
Whisk vigorously.
Add the almond meal.
No more whisking. This time use a spoon to mix everything. The result should be a soft and somewhat loose cookie dough that will hold whatever shape you want to give it.
Make small balls of about 4cm and roll them in the icing sugar. Then shape them however you like and put on a baking tray lined with baking paper (no need to grease it up).

Cooking

Bake at 180'C for 15 mins. The aim is to make thick cookies that are somewhat crunchy outside and soft and sligthly chewy on the inside, so bear in mind that any shape less than 2cm thick will cook quickly and get crunchy quickly.

After baking, you can use any leftover icing sugar to dust the lot, or you can just enjoy them 'au naturel'.

Enjoy!
M.

Marco's Pancakes

2010-05-22T10:00:00.002+10:00

Makes 6-8 hand-sized pancakes.

Ingredients

1 cup of self-raising flour
1 cup of semi-skimmed milk
1/2 cup of almond meal
1 egg
2 tablespoons of sugar
1 teaspoon of margarine
1 tablespoon of lemon juice
1/2 teaspoon of baking powder
pinch of salt

Preparation
Put the margarine and the milk in a pan and warm them up slowly. The milk must be just warm, not hot, and the margarine should be all melted. Stir gently if needed.
While the milk is warming up, sift the flour and almond meal in a bowl, then add the sugar, the salt and the baking powder.
Beat the egg and the lemon juice lightly and leave it on the side.
When the milk is warm and the margarine has melted, add the beaten egg to the flour, then the warm milk and start whisking. If the milk is hot, the egg will start cooking immediately and the mixture will get lumpy. Whisk until you get a smooth dense mixture . If it's too liquid, sift more flour into it while whisking.
Leave the pancake mix to rest for a minute or two.

Cooking
While the pancake mix is resting, you can use this time to start heating up a frying pan on a medium-high heat. If the heat is too high the pancakes will burn easily on the outside without cooking properly, so this might take a little bit of experimenting.
I use olive oil to cook the pancakes, but some people prefer butter or margarine. With olive oil, I use a few drops in the middle of the pan and then shake the pan vigorously so that lots of tiny droplets roughly cover the whole surface.
Gently pour the pancake mix in the middle of the pan and let it cook for just over a minute. You should see lots of little bubbles being produced, covering pretty much the whole pancake. After a minute, check the bottom of the pancake: if it's a bit brown it's time to turn it over and let it cook for another minute or less.

The size of the bubbles depends on how much baking powder you put in the mix, so if few or no bubbles appear you can try adding a quarter of a teaspoon of baking powder to the mix and whisk again throughly.

Enjoy.

RAIDers of the Lost Disk (again)

2010-04-02T22:13:00.004+11:00

Here we go again. The NAS is not happy.
Just out of curiosity, I see if there is a hacked firmware based on a more recent image, and I find one based on version 3.4.90, with SSH of course.
So here we go. Let's check the RAID device...

~ # mdadm --detail /dev/md0
/dev/md0:
        Version : 00.90.01
  Creation Time : Sat May  5 06:30:50 2007
     Raid Level : raid1
     Array Size : 487106752 (464.54 GiB 498.80 GB)
    Device Size : 487106752 (464.54 GiB 498.80 GB)
   Raid Devices : 2
  Total Devices : 1
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Fri May 22 15:20:30 2009
          State : clean, degraded
 Active Devices : 1
Working Devices : 1
 Failed Devices : 0
  Spare Devices : 0

           UUID : 7ff7415e:4719112d:d63dd33d:40ff685f
         Events : 0.525126

    Number   Major   Minor   RaidDevice State
       0       0        0        -      removed
       1       8        6        1      active sync   /dev/sda6

Again only one drive out of two.
Let's see what happened to /dev/sdb.

~ # /usr/sbin/smartctl -l selftest /dev/sdb
smartctl version 5.1-14 Copyright (C) 2002-3 Bruce Allen
Home page is http://smartmontools.sourceforge.net/

=== START OF READ SMART DATA SECTION ===
SMART Self-test log, version number 1
Num  Test_Description    Status                  Remaining  LifeTime(hours)  LBA_of_first_error
# 1  Extended off-line   Completed                     00%      7474         -
# 2  Off-line            Interrupted (host reset)      50%      7466         -
# 3  Off-line            Interrupted (host reset)      50%      7379         -
# 4  Short off-line      Completed: read failure       50%      7334         0x00032141
# 5  Off-line            Interrupted (host reset)      00%      7334         -
# 6  Short off-line      Completed                     00%      7330         -
# 7  Off-line            Interrupted (host reset)      00%      7330         -
# 8  Off-line            Interrupted (host reset)      00%      5973         -
# 9  Off-line            Interrupted (host reset)      00%      5396         -
#10  Off-line            Interrupted (host reset)      00%      5393         -
#11  Off-line            Interrupted (host reset)      00%      5376         -
#12  Short off-line      Completed                     00%      4687         -
#13  Off-line            Interrupted (host reset)      00%      4687         -
#14  Off-line            Interrupted (host reset)      00%      4003         -
#15  Off-line            Interrupted (host reset)      00%      3819         -
#16  Short off-line      Completed                     00%      3659         -
#17  Short off-line      Completed                     00%      3659         -
#18  Short off-line      Completed                     00%      3655         -
#19  Off-line            Interrupted (host reset)      70%      3652         -
#20  Short off-line      Aborted by host               70%      3652         -
#21  Off-line            Interrupted (host reset)      00%      3651         -

Ouch! LBA_of_first_error = 0x32141 (= 205121 in base 10)
Let's check also the SMART attributes.

~ # /usr/sbin/smartctl -A /dev/sdb
smartctl version 5.1-14 Copyright (C) 2002-3 Bruce Allen
Home page is http://smartmontools.sourceforge.net/

=== START OF READ SMART DATA SECTION ===
SMART Attributes Data Structure revision number: 32
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME          FLAG     VALUE WORST THRESH TYPE      UPDATED  WHEN_FAILED RAW_VALUE
  3 Spin_Up_Time            0x0027   168   162   063    Pre-fail  Always       -       18676
  4 Start_Stop_Count        0x0032   210   210   000    Old_age   Always       -       20884
  5 Reallocated_Sector_Ct   0x0033   253   253   063    Pre-fail  Always       -       0
  7 Seek_Error_Rate         0x000a   253   252   000    Old_age   Always       -       0
  8 Seek_Time_Performance   0x0027   247   243   187    Pre-fail  Always       -       41160
  9 Power_On_Hours          0x0032   232   232   000    Old_age   Always       -       7559
 10 Spin_Retry_Count        0x002b   253   252   157    Pre-fail  Always       -       0
 11 Calibration_Retry_Count 0x002b   253   252   223    Pre-fail  Always       -       0
 12 Power_Cycle_Count       0x0032   253   253   000    Old_age   Always       -       76
189 Unknown_Attribute       0x003a   100   100   000    Old_age   Always       -       0
190 Unknown_Attribute       0x0022   056   039   000    Old_age   Always       -       959119404
192 Power-Off_Retract_Count 0x0032   253   253   000    Old_age   Always       -       0
193 Load_Cycle_Count        0x0032   253   253   000    Old_age   Always       -       0
194 Temperature_Celsius     0x0032   046   253   000    Old_age   Always       -       44
195 Hardware_ECC_Recovered  0x000a   252   210   000    Old_age   Always       -       37129
196 Reallocated_Event_Count 0x0008   253   253   000    Old_age   Offline      -       0
197 Current_Pending_Sector  0x0008   253   253   000    Old_age   Offline      -       0
198 Offline_Uncorrectable   0x0008   253   253   000    Old_age   Offline      -       0
199 UDMA_CRC_Error_Count    0x0008   199   199   000    Old_age   Offline      -       0
200 Multi_Zone_Error_Rate   0x000a   253   252   000    Old_age   Always       -       0
201 Soft_Read_Error_Rate    0x000a   253   252   000    Old_age   Always       -       0
202 Unknown_Attribute       0x000a   253   252   000    Old_age   Always       -       0
203 Unknown_Attribute       0x000b   253   252   180    Pre-fail  Always       -       11
204 Unknown_Attribute       0x000a   253   252   000    Old_age   Always       -       0
205 Unknown_Attribute       0x000a   253   252   000    Old_age   Always       -       0
207 Unknown_Attribute       0x002a   253   252   000    Old_age   Always       -       0
208 Unknown_Attribute       0x002a   253   252   000    Old_age   Always       -       0
210 Unknown_Attribute       0x0032   253   252   000    Old_age   Always       -       0
211 Unknown_Attribute       0x0032   253   252   000    Old_age   Always       -       0
212 Unknown_Attribute       0x0032   253   252   000    Old_age   Always       -       0

Not too bad after all, since
Current_Pending_Sector = 0
Offline_Uncorrectable = 0

Now let's find which partition has the problem.

~ # fsck.ext3 -nv /dev/sdb1
e2fsck 1.38 (30-Jun-2005)
/dev/sdb1: clean, 3045/64256 files, 24511/64252 blocks

~ # fsck.ext3 -nv /dev/sdb2
e2fsck 1.38 (30-Jun-2005)
Warning!  /dev/sdb2 is mounted.
Warning: skipping journal recovery because doing a read-only filesystem check.
/dev/sdb2 contains a file system with errors, check forced.
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
/lost+found not found.  Create? no

Pass 4: Checking reference counts
Pass 5: Checking group summary information
Free blocks count wrong (39452, counted=39449).
Fix? no

Free inodes count wrong (61113, counted=61112).
Fix? no


/dev/sdb2: ********** WARNING: Filesystem still has errors **********


    2887 inodes used (4%)
      13 non-contiguous inodes (0.5%)
         # of inodes with ind/dind/tind blocks: 156/0/0
   24548 blocks used (38%)
       0 bad blocks
       1 large file

    2309 regular files
     175 directories
      47 character device files
      40 block device files
       0 fifos
       8 links
     308 symbolic links (308 fast symbolic links)
       0 sockets
--------
    2887 files

/dev/sdb3 is a swap partition, so we can skip that.
/dev/sdb4 is an extended partition, so we can skip that too.

~ # fsck.ext3 -nv /dev/sdb5
e2fsck 1.38 (30-Jun-2005)
Warning!  /dev/sdb5 is mounted.
Warning: skipping journal recovery because doing a read-only filesystem check.
/dev/sdb5 contains a file system with errors, check forced.
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
/lost+found not found.  Create? no

Pass 4: Checking reference counts
Pass 5: Checking group summary information
Free blocks count wrong (118269, counted=118286).
Fix? no

Free inodes count wrong (126523, counted=126537).
Fix? no


/dev/sdb5: ********** WARNING: Filesystem still has errors **********


      69 inodes used (0%)
       4 non-contiguous inodes (5.8%)
         # of inodes with ind/dind/tind blocks: 0/0/0
    8235 blocks used (6%)
       0 bad blocks
       1 large file

      32 regular files
      14 directories
       0 character device files
       0 block device files
       0 fifos
       0 links
       0 symbolic links (0 fast symbolic links)
       0 sockets
--------
      46 files

~ # fsck.ext3 -nv /dev/sdb6
e2fsck 1.38 (30-Jun-2005)
/dev/sdb6: clean, 93575/60899328 files, 56875141/121776688 blocks

So the errors are on /dev/sdb2 and /dev/sdb5
Let's see where they mount to.

~ # mount | grep /sdb
/dev/sdb1 on /mnt/__mxo_sdb1 type ext3 (rw)

~ # cat /proc/mounts | grep /sdb
/dev/sdb5 /tmp ext3 rw 0 0

~ # cat /proc/cmdline
console=ttyS0,115200 root=/dev/sdb2 rw

Are we booting from /dev/sdb2?

~ # mxoparam -h

Maxtor mxoparam version 1.0
-a         show all maxtor params
-b         get wait for button status
-c [0-1]        set wait for button 0 = Off 1 = On
-d         show max number of drives
-e         enable watchdog in uboot
-f         disable watchdog in uboot
-g         set led solid green
-h         show help
-k         kick watchdog
-p         get boot partition
-q [part]  set boot partition
           0 = drive 0 partition 1
           1 = drive 0 partition 2
           2 = drive 1 partition 1
           3 = drive 1 partition 2
-r         reset partion fail count
-s         get serial number
-t [sn]    set serial number
-v         show version
-x         disable watchdog now
-w         enable watchdog now
-y         set led solid yellow

~ # mxoparam -p
Boot partition is 3

Looks like the system is booting from the second disk, second partition (/dev/sdb2)
This means we can't unmount it, and we need to unmount it before we can fix it.
Therefore, we need to make the system boot from /dev/sda2 otherwise we won't be able to fix /dev/sdb*

First of all, let's make sure /dev/sda2 is exactly the same as /dev/sdb2

~ # dd if=/dev/sdb2 of=/dev/sda2

~ # mount -n /dev/sda2 /mnt/__mxo_sda2 -t ext3

~ # cp -a /mnt/__mxo_sdb2 /mnt/__mxo_sda2


Now let's set the new boot partition





~ # mxoparam -q 1
REBOOT!
...
Let's check it's booting up from the right place now.





~ # cat /proc/cmdline
console=ttyS0,115200 root=/dev/sda2 rw
Right! We're ready to fix /dev/sdb2 and /dev/sdb5 now!





~ # fsck -v /dev/sdb2
fsck 1.38 (30-Jun-2005)
e2fsck 1.38 (30-Jun-2005)
/dev/sdb2 has gone 384 days without being checked, check forced.
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
/lost+found not found.  Create? yes

Pass 4: Checking reference counts
Pass 5: Checking group summary information

/dev/sdb2: ***** FILE SYSTEM WAS MODIFIED *****

    3157 inodes used (4%)
      14 non-contiguous inodes (0.4%)
         # of inodes with ind/dind/tind blocks: 159/0/0
   24622 blocks used (38%)
       0 bad blocks
       1 large file

    2317 regular files
     179 directories
     246 character device files
      84 block device files
       0 fifos
       7 links
     321 symbolic links (321 fast symbolic links)
       0 sockets
--------
    3154 files


~ # fsck -v /dev/sdb5
fsck 1.38 (30-Jun-2005)
e2fsck 1.38 (30-Jun-2005)
/dev/sdb5: recovering journal
/dev/sdb5 has been mounted 35 times without being checked, check forced.
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
/lost+found not found.  Create? yes

Pass 4: Checking reference counts
Pass 5: Checking group summary information

/dev/sdb5: ***** FILE SYSTEM WAS MODIFIED *****

    2939 inodes used (2%)
      28 non-contiguous inodes (1.0%)
         # of inodes with ind/dind/tind blocks: 159/0/0
   26690 blocks used (21%)
       0 bad blocks
       1 large file

    2345 regular files
     189 directories
      47 character device files
      40 block device files
       0 fifos
       8 links
     308 symbolic links (308 fast symbolic links)
       0 sockets
--------
    2937 files
Now we can rebuild the RAID array.







~ # mdadm --manage --add /dev/md0 /dev/sdb6
mdadm: hot added /dev/sdb6
NAS:~ # mdadm --detail /dev/md0
/dev/md0:
        Version : 00.90.01
  Creation Time : Sat May  5 06:30:50 2007
     Raid Level : raid1
     Array Size : 487106752 (464.54 GiB 498.80 GB)
    Device Size : 487106752 (464.54 GiB 498.80 GB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Sat May 23 14:39:50 2009
          State : clean, degraded, recovering
 Active Devices : 1
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 1

 Rebuild Status : 0% complete

           UUID : 7ff7415e:4719112d:d63dd33d:40ff685f
         Events : 0.541445

    Number   Major   Minor   RaidDevice State
       0       0        0        -      removed
       1       8        6        1      active sync   /dev/sda6

       2       8       22        0      spare rebuilding   /dev/sdb6

~ # cat /proc/mdstat
Personalities : [linear] [raid1]
md0 : active raid1 sdb6[2] sda6[1]
      487106752 blocks [2/1] [_U]
      [>....................]  recovery =  1.5% (7396736/487106752) finish=145.1min speed=55092K/sec
unused devices: [none]
Good... 
2.5 hours later...






~ # cat /proc/mdstat
Personalities : [linear] [raid1]
md0 : active raid1 sdb6[0] sda6[1]
      487106752 blocks [2/2] [UU]

unused devices: [none]
Reboot again and we're done!

Maxtor Shared Storage II - LED Codes

2010-04-02T08:05:00.004+11:00

I just want to write this for future reference, since the relevant link on the Seagate support website has already changed a couple of times and I don't want to keep wasting time looking for it next time it changes.

Back Panel LED Codes

LED	Definition	Status
Power LED (located in center of the power button)	Power Switch	Illuminated - Power On Not Illuminated - Power Off
Ethernet LED (located on bottom side of Ethernet connector)	Shows if the drive is connected through a 10/100 or a 1 Gb Ethernet connection. Left Green - 10/100 Mbps Ethernet connectivity Left Amber - 1 Gbps Ethernet connectivity	Illuminated - Power On Blinking - Network communication is occurring Not Illuminated - Power Off
Activity LED (located on top side of Ethernet connector)	A flashing Activity LED indicates that the network connection is functional and that packets are being transmitted or received.

Front Panel LED Codes

LED	Definition	Status
Top	Power Activity	Illuminated - Power On Blinking - Drive is either powering up or shutting down Not Illuminated - Power Off
Center	Hard Disk Activity	Illuminated - Power On Blinking - Data is being transferred to/from the drive Not Illuminated - Power Off
Bottom	Network Activity	Illuminated - Power On Blinking - Network communication is occurring Not Illuminated - Power Off

Front Panel LED Error Codes

Green LED - Number of Blinks	Amber LED - Number of Blinks	Status
1	4	/share file system error
1	3	Boot Error - Attempting to boot from disk 0
2	3	Boot Error - Attempting to boot from disk 1
1	2	HDD S.M.A.R.T. Error - Attempting to boot from disk 0
2	2	HDD S.M.A.R.T. Error - Attempting to boot from disk 1
1	1	RAID Error

Software Engineering Wishlist #1

2010-03-19T22:07:00.005+11:00

This is just the beginning of a wishlist for my software engineering and development world. Things I would like to be able to do, technology trends etc. I expect this wishlist to be continuously expanding, so this is only part 1.

I want to be able to...
...check my continuous integration status and logs from FaceBook.
...get my continuous integration results via SMS.
...update Bugzilla/Jira/whatever discussion threads via Twitter
...do some pair programming with something like Google Docs
...do some pair programming with a some kind of real-time plugin for Eclipse
...bring online and shut down continuous integration nodes with Google App Engine
...bring online and shut down full QA stacks with Amazon EC2
...manage user stories with my smartphone
...write actual code with my smartphone on the train and upload/synchronise it later
...use my smartphone as a code repository for small projects
...use my smartphone's voice recognition capabilities to actually dictate code to it
...perform code reviews with some kind of real-time plugin for Bugzilla/Jira/whatever

More to come.
M.

RAIDers of the Lost Disk

2010-03-15T11:37:00.006+11:00

A few years ago I decided it was a good idea to have a dedicated file server in my home. After a bit of looking around, I set my mind on a Maxtor Shared Storage II - 1TB. This has 2 drives of 500GB each inside, and it can be set up as a Raid-0 or Raid-1 device. It is configured via a simple web interface.
I bought one and configured it as a Raid-1 device. After a short while, I also decided to update the firmware with a version based on OpenMSS.

Shortly after the warranty expired, one of the drives failed badly. The clicking that was coming out of it was pretty loud but in a twisted way also quite pleasant, somehow clicking along with Bob Marley's "Redemption Songs". Anyway, I managed to replace the faulty drive and rebuild the array, and my file server has been living happily ever since... until yesterday.

It was either a power failure or a loose PSU connector, or both. As a result, the power light started flashing alternatively green (once) and amber (once). I went to the diagnostics page only to find that my device was functioning "within normal parameters". Hmmm... that can't be right.

~ # mdadm --detail /dev/md0
/dev/md0:
        Version : 00.90.01
  Creation Time : Sat May  5 06:30:50 2007
     Raid Level : raid1
     Array Size : 487106752 (464.54 GiB 498.80 GB)
    Device Size : 487106752 (464.54 GiB 498.80 GB)
   Raid Devices : 2
  Total Devices : 1
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Tue May  5 11:18:29 2009
          State : active, degraded
 Active Devices : 1
Working Devices : 1
 Failed Devices : 0
  Spare Devices : 0

           UUID : 7ff7415e:4719112d:d63dd33d:40ff685f
         Events : 0.515034

    Number   Major   Minor   RaidDevice State
       0       8       22        0      active sync   /dev/sdb6
       1       0        0        -      removed

What??? Removed??? How???

~ # mdadm --examine /dev/sda6
mdadm: cannot open /dev/sda6: No such file or directory
mdadm: cannot find device size for /dev/sda6: No such file or directory

Hmmm...

~ # ls /dev/sd*
/dev/sda   /dev/sda3  /dev/sda6  /dev/sdb1  /dev/sdb4  /dev/sdb7
/dev/sda1  /dev/sda4  /dev/sda7  /dev/sdb2  /dev/sdb5
/dev/sda2  /dev/sda5  /dev/sdb   /dev/sdb3  /dev/sdb6

~ # cat /proc/partitions
major minor  #blocks  name

   8    16  488386584 sdb
   8    17     257008 sdb1
   8    18     257040 sdb2
   8    19     257040 sdb3
   8    20          1 sdb4
   8    21     506016 sdb5
   8    22  487106833 sdb6
   8     0  488386584 sdc
   8     1     257008 sdc1
   8     2     257040 sdc2
   8     3     257040 sdc3
   8     4          1 sdc4
   8     5     506016 sdc5
   8     6  487106833 sdc6
  31     0        256 mtdblock0
   9     0  487106752 md0

How exactly did my sda partitions become sdc? Reboot? Yes, reboot!
... [reboot] ...

~ # cat /proc/partitions
major minor  #blocks  name

   8     0  488386584 sda
   8     1     257008 sda1
   8     2     257040 sda2
   8     3     257040 sda3
   8     4          1 sda4
   8     5     506016 sda5
   8     6  487106833 sda6
   8    16  488386584 sdb
   8    17     257008 sdb1
   8    18     257040 sdb2
   8    19     257040 sdb3
   8    20          1 sdb4
   8    21     506016 sdb5
   8    22  487106833 sdb6
  31     0        256 mtdblock0
   9     0  487106752 md0

That's better, but how... ??? Anyway, let's check sda6.

~ # mdadm --query /dev/sda6
/dev/sda6: is not an md array
/dev/sda6: device 1 in 2 device mismatch raid1 md0.  Use mdadm --examine for more detail.

~ # mdadm --examine /dev/sda6
/dev/sda6:
          Magic : a92b4efc
        Version : 00.90.01
           UUID : 7ff7415e:4719112d:d63dd33d:40ff685f
  Creation Time : Sat May  5 06:30:50 2007
     Raid Level : raid1
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 0

    Update Time : Fri May  1 20:10:03 2009
          State : clean
 Active Devices : 2
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 0
       Checksum : 34c79134 - correct
         Events : 0.513042


      Number   Major   Minor   RaidDevice State
this     1       8        6        1      active sync   /dev/sda6

   0     0       8       22        0      active sync   /dev/sdb6
   1     1       8        6        1      active sync   /dev/sda6

Mismatched, as I would expect, but it's clean. Good.

~ # mdadm --manage --add /dev/md0 /dev/sda6
mdadm: hot added /dev/sda6

~ # mdadm --detail /dev/md0
/dev/md0:
        Version : 00.90.01
  Creation Time : Sat May  5 06:30:50 2007
     Raid Level : raid1
     Array Size : 487106752 (464.54 GiB 498.80 GB)
    Device Size : 487106752 (464.54 GiB 498.80 GB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Tue May  5 11:22:02 2009
          State : clean, degraded, recovering
 Active Devices : 1
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 1

 Rebuild Status : 0% complete

           UUID : 7ff7415e:4719112d:d63dd33d:40ff685f
         Events : 0.515210

    Number   Major   Minor   RaidDevice State
       0       8       22        0      active sync   /dev/sdb6
       1       0        0        -      removed

       2       8        6        1      spare rebuilding   /dev/sda6

Rebuilding. Good sign, but why do I stil have device 1 - removed - in the list?

~ # cat /proc/mdstat
Personalities : [linear] [raid1]
md0 : active raid1 sda6[2] sdb6[0]
      487106752 blocks [2/1] [U_]
      [=>...................]  recovery =  9.8% (47870464/487106752) finish=114.8min speed=63713K/sec
unused devices: none

Under 2 hours to sync up. Time for coffee.
... [coffee] ...

~ # cat /proc/mdstat
Personalities : [linear] [raid1]
md0 : active raid1 sda6[1] sdb6[0]
      487106752 blocks [2/2] [UU]
unused devices: none

~ # mdadm --detail /dev/md0
/dev/md0:
        Version : 00.90.01
  Creation Time : Sat May  5 06:30:50 2007
     Raid Level : raid1
     Array Size : 487106752 (464.54 GiB 498.80 GB)
    Device Size : 487106752 (464.54 GiB 498.80 GB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Tue May  5 14:05:25 2009
          State : clean
 Active Devices : 2
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 0

           UUID : 7ff7415e:4719112d:d63dd33d:40ff685f
         Events : 0.515939

    Number   Major   Minor   RaidDevice State
       0       8       22        0      active sync   /dev/sdb6
       1       8        6        1      active sync   /dev/sda6

One last reboot and we're back on track.
Sorted.

Eclipsed by an Ant

2010-02-18T22:02:00.004+11:00

I've been stuck on a web project for a while. Well, not really on the project itself, I've actually been stuck on running it with the GlassFish Tools Bundle for Eclipse v1.2.

The bundle comes with two version of GlassFish: v2.1 and v3 Prelude. I never had problems running the project on v3, but every time I tried to use to v2.1 my Eclipse would get stuck during the publishing phase with this message: "Publishing to Bundled GlassFish, waiting for virtual machine to exit..."

It turns out that the difference in the publishing phase between the bundled GlassFish v2.1 and v3 is that the former uses Apache Ant. So I checked the Ant runtime home entries on Eclipse and found out they were messed up, pointing at the Axis2 plugin! I must have happened during the installation of the Axis2 Code Generator Wizard. Fixing the Ant home entries finally allowed me to publish the project to the bundled GlassFish v2.1

Here are the steps in Eclipse 3.4 (Ganymede):

Click on Windows -> Preferences
Expand the Ant node and select the Runtime child node
In the Classpath tab, select Ant Home Entries from the list
Click the Ant Home button to bring up the folder browser
In the folder browser, navigate to the folder where Ant was installed
Click OK to go back to the Eclipse preferences dialog
Click Apply, then click OK

Done.
M.

Pythagoras On Screen

2009-10-27T00:33:00.002+11:00

Euclid of Alexandria "invented" geometry. Before him, there was no squares or circles. Everything was just a collection of messy shapes. One even wonders how they managed to build houses without straight lines and triangles.

Ok, just kidding...

Pythagoras of Samos actually did know a thing or two about triangles before Euclid ever did, so much so that he discovered the mathematical relationship between the sides of right-angled triangles.
How are these two gentlemen related? Well, they lived a couple of centuries apart, so they are not directly related to each other as such, but in terms of mathematics they are very closely related: the pythagorean theorem only "works properly" in euclidean spaces.

What are euclidean spaces? They are those spaces that satisfy the axioms of Euclidean geometry. Most of us have studied Euclidean geometry at school: we learn that the shortest path between two points is the straight line, that the sum of the angles of a triangle is 180 degrees, and other wonderful rules.
A lot of these rules, however, start falling apart when we try to apply them to non-Euclidean geometries. In general, though, if we stick to flat 2-D surfaces (like a piece of paper), Euclid's rules will survive just fine.

Let's test this.

If we draw on a piece of paper a right-angled triangle, with one leg being 300mm long and the other being 400mm long, Pythagoras taught us that the hypotenuse should be 500mm long, and indeed it is. In general, the hypotenuse will always be longer than either of the two legs.
What else do we have, apart from a piece of paper resting on a desk, that is a flat 2-D surface? Well, there's the flat LCD screen on which I'm writing this article, of course. So if I draw a segment that is 300 pixels long, at a right angle with another segment that is 400 pixels long, then I should be able to join the two open ends of each segment with a third segment that is 500 pixels long, right?

Wrong.

Why? The reason is not that difficult to find: the computer screen is not a continuous surface: it's made out of "tiles" called pixels, and each pixel is either turned on or off. There is no such thing as a fractionary pixel, so you can't draw half a pixel, or two-third of a pixel: you either draw it entirely or you don't. In other words, the surface of my LCD screen is quantised. So when the two legs of my right-angled triangle on screen are 12 and 8 pixels long, the hypotenuse cannot possibly be 14.42 pixels. So how long is it? 14 pixels? 15 pixels? Does it round up by eccess or by defect?

Well... Neither.

It turns out that it depends on how you want to draw the line so that it appears continuous to the average person looking at the screen. I think two pixels can be considered contiguous if they touch each other one way or another, even if only by one corner. Sticking to this constraint, the minimum number of pixels required to draw the hypotenuse of the above triangle would be 12, which is the same number of pixels required to draw the longest leg of the triangle.

In my head, this means two very important things:

quantised surfaces are not Euclidean in nature, even though they may intuitively appear to be so
the concept of "distance" between two points on a quantised surface is very, very funny

To Infinity and Beyond

2009-09-10T19:28:00.003+10:00

Here's a thought...

Let's take two series, call them A and B.
Let's say each term in A is less than or equal to the corresponding term in B.
Logic would suggest that, if B is convergent, then A is convergent too.

So how about this...

Let B be the geometric series 1 + 2/3 + 4/9 + 8/27 + ... + (2/3)^N + ...
This series converges to 3.

Let A be the series 1 + 1/2 + 1/3 + 1/4 + ... + (1/N) + ...
This series is not convergent.

However, each term of A is less than or equal to the corresponding term in B, i.e.
1 <= 1 1/2 <= 2/3 1/3 <= 4/9 1/4 <= 8/27 ... 1/N <= (2/3)^N ...

If B is convergent, doesn't this mean that A should be convergent too?
Hmmmm...
M.

Ushiro Irimi Nage

2009-08-21T06:08:00.001+10:00

No, there's no such thing as ushiro irimi nage, as far as I know... or is there?

I was training as usual on Thursday, starting with one hour of aiki-jo (time to brush up the 13 jo kata), then off to tai jutsu. Without fail, we start with some tai no henko and morote dori kokkyu nage, and that's when I had the idea.

After years of kokkyu nage, I never cease to find inspiration from this technique. It's difficult to explain the technique in words, as most aikidokas will know, but I'll try, so here are the basic concepts (in my opinion) of the morote dori kokkyu nage basic form:

Engage kokkyu.
Slight step on the side, just enough to misalign the direction of attack.
Lower the centre while keeping an upright posture, to break a potential arm lock.
Turn and change hanmi while cutting upwards as if with aiki-ken.
Enter uke's space while extending kokkyu up and to the rear (this breaks uke's balance).
Rotate upper body (this starts the nage as uke starts falling backwards).
Settle extending kokkyu down and to the rear (this completes the nage).

...and there was my revelation: steps 5, 6, and 7 are also the steps that complete all irimi nage techniques (at least in my head they are). Here's what I see happening in the irimi nage basic form, independently of the attack:

Enter uke's space while extending kokkyu up and at the front (this breaks uke's balance).
Rotate upper body as in the fourth jo subury (this starts the nage as uke starts falling backwards).
Settle extending kokkyu downwards (this completes the nage).

There are technical differences, of course. For example, the nage in irimi nage is always performed to the front, and it uses aiki-jo movements instead of aiki-ken, but both techniques are about entering uke's space strongly, extending kokkyu through uke's space, rotating the upper body and completing the nage by settling the body weight and extending kokkyu downwards.

Now, every time I think of the basic form of kokkyu nage I think of "ushiro irimi nage", or "irimi nage to the rear", and that changes the whole perspective of this technique. Is it right? Is it wrong? It doesn't matter. Every so often in aikido I find something that turns all my understandings upside down, or even throw them out of the window to start again from scratch, and that's why I love it.
M.