RIT TCOM333 Student Blog

Main menu

I think the most important thing I learned in this class is that I should be writing my work with an audience in mind. While I have had several classes focused on the user experience as someone on the website development and database management path, I’ve had very few writing classes. Those that I have taken were generally all about the content and analysis aspect of writing – I think the last time I even heard someone mention I should bother considering an audience at all was when I was writing college essays. However, this class has not only reminded me that writing deserves the same audience-focused approach as other aspects of website development, it’s also given me a framework in which to develop an understanding of who I’m writing for (often a difficult question to answer).

This is the way that this class has changed the way I approach my work. I no longer feel I am guessing about who my audience is but that, instead, I have a path to discovering my audience. The book gave a lot of really helpful advice through it’s ‘three step’ method to identifying readers. The first was to identify who the readers were – primary action takers, secondary advisors, tertiary evaluators, or gatekeepers/supervisors. However beyond just identifying the readers and their roles in relation to your documentation, the book also helped delineate that writers need to understand the needs, values, attitudes, and contexts of readers.

For example, the book’s second step is to identify the reader’s needs, values, and attitudes by determining their familiarity with the subject matter, professional experience, education/reading comprehension, skill level, and concerns. Writers are also meant to ask questions like: what information are my readers looking for? What are their pre-existing attitudes towards me, my company, and my subject matter? The last step is to identify the context in which a reader discovers your document – this has to do with the physical, economic, political, and ethical climate in which a reader experiences your writing. While step one felt intuitive, steps two and three were harder to grasp even though they were clearly critical to the way a reader interprets documentation.

Exercises like ‘Installing a Medical Waste Incinerator’ were the most helpful in demonstrating how to gain an understanding of one’s audience, and allowing me to put into practice the advice given in the book. To me, this is the most valuable thing I learned in the class that will change how I approach my work in the future.

Advertisements

Share this:

Like this:

Early web designers learned to develop in older versions of HTML, CSS, and JavaScript – a lot of those earlier technologies, while revolutionary at the time, did not provide very many options or work effectively for what the web designers wanted to do. In addition, many of the browsers interacted with these languages differently.

Modern web designers have a lot more options when it comes to building a website. Just some of the skills include utilizing new features of HTML5 (which encompasses HTML, CSS, and JavaScript but the languages are built to work together), frameworks, build tools, and information search technologies. The importance of each of these modern tools accessible to web designers will be expanded upon in more detail in this post.

HTML5:

HTML5 is the code that makes up the entire website; everything on the page is made up of HTML5 elements. HTML5 is relatively recent, but incredibly important, to the field of web design. This is because it allows for better implementation across browsers; instead of needing to write separate, specific code for each potential browser an end user could be utilizing, the code will work the same for all browsers. HTML5 is code that makes up the entire website so it is clearly a critical skill for the modern web designer; however coding the whole website independently can be unwieldy and time consuming, so other tools are also now available to make utilizing HTML5 to design a website more efficient.

Frameworks:

Frameworks are large code sets that are ‘prebuilt’ website elements. A popular example is Bootstrap, which has a CSS theme you can utilize, example templates using their HTML elements, and pre-made JavaScript elements. Basically, Bootstrap has all the right stuff already coded so that anyone can build a pretty nice website out of just Bootstrap, which is just one of many frameworks available. A good, modern web designer will utilize frameworks to make coding a website go a lot faster.

Build Tools:

Build tools like Grunt and Gulp do the boring work for you. Basically, they help you implement your framework by putting the elements of the framework in the right spots. Grunt and Gulp do essentially the same thing but in different ways; it’s still important for the modern web designer to know the difference between these two tools and use them effectively to save time building the website. Most people end up generally using one or the other, but there are strengths and weaknesses to both so it’s critical that the modern web designer know how to use both Grunt and Gulp.

Information Search Technologies:

Google has become a powerful tool for any modern web designer; if you can think it, someone has likely done it or something just like it. Being able to search google effectively for the information you need is a critical skill for the modern web designer.

Share this:

Like this:

In web development, plain language can mean the difference between a user continuing to engage with the website or clicking open a new tab. Particularly the landing page of a website should have engaging, almost casual language; it’s critical that users feel at home when they see the first page. Scary, overly technical or verbose language presented in an ineffective, cramped style will only serve to severe your connection with readers.

In my HCI classes, I’ve learned mostly how to style content so that it isn’t hard to consume. I have learned how to use visual elements (sparingly) to highlight important sections of text that are key to understanding, and how to weave links to new pages into the content to create a reference system to improve user understanding. We often discuss the importance of font size and color and the importance of white space (which can be used to frame text but also eases the burden on a reader when trying to scan the page). Page color in particular can set a tone for the webpage and ideally should be consistent across all the pages; utilizing one or two colors in a variety of shades is more comfortable to readers than consistently startling them with lots of different, bright colors. As you can probably tell, we talk a lot about design in my HCI classes and there’s a big push to keep the design ‘plain’.

Often (in my understanding), web developers use pre-existing content prepared by a technical writer. This may be why we haven’t discussed plain language as much as simple design principles. However, were I to become a freelance web developer it could become necessary for me to develop my own content. If that’s the case, I need to be able to make content that matches my designs (that is, simple and engaging). Plain language means using less technical language.

On websites, it’s easy to offer external links to define tricky terms that simply must be included in the content. Breaking up that content into easy-to-manage sections is also important to allow users to find the content they’re looking for. It’s important to be concise whenever possible; less is more, with content. The design element of white space becomes critical here; the longer a section of text, the less likely the users are to continue reading it.

Plain language works well with plain design in my field; both the content and the way it is displayed should be simple to encourage users to engage with the website.

Share this:

Like this:

Current Process

The Waterfall Model is a process used in software development. There are five steps to the Waterfall Model:

Requirements – assess the requirements of the program by meeting with project managers. This step requires research: talk with users, interview the people who commissioned the software, do additional research using web and print sources, etc.

Design – Figure out how you’re going to code the program to meet the requirements from step 1. What libraries will you use? What languages? Write down/map out these elements of the design.

Implementation – Code everything to the specifications of your design.

Verification – Test that the produced code functions correctly without errors.

Maintenance – There were definitely errors. Go fix them. Additionally, any updates or changes that clients desire may be added at this time.

Changes:

This model is a fairly simple, effective model of software development but could use some small changes to make it more flexible for larger projects. I would leave step one as is, since it is critical to gather information first so you know what the requirements of your program are (this will inform everything else you do). I would then design the major components of the whole program, as in step 2. Here, I would start making changes.

Rather than design the whole program, then implement the whole program, then verify the whole program, I would break the overall program design into smaller pieces. So my new step three would be to define reasonably sized pieces of the overall software. Steps 4a-6a would be to start with one of these pieces, a, and design it more thoroughly, implement it, and verify it. Then I would go back to step 4 and repeat 4n-6n for n number of parts of the software.

After the final step 6, I would then go on to verify the entire program (step 7) and maintain the entire program (step 8).

The benefit of doing software development this way is that you can more readily address changes to the program as you go. Also, there are fewer problems occurring at a time and they’re smaller problems because you’re working on a smaller section of the program. This allows you to dedicate time, energy, and resources to effectively solving each problem. As software development becomes increasingly collaborative, this is also a really good strategy for working with teams. Each person can be working steps 4-6 on a different part of the program, parallelizing the process and maximizing efficiency.