Model View Controller and Event Driven UI
- 1 Slides
- 2 Readings
- 3 Reading Critiques
- 3.1 Ariella Hanna 11:27:55 1/23/2017
- 3.2 Chad Pongratz 13:52:50 1/24/2017
- 3.3 Jonathan Hanobik 16:15:59 1/24/2017
- 3.4 Louis Seefeld 18:59:18 1/24/2017
- 3.5 Vivien Chang 19:42:50 1/24/2017
- 3.6 Nick Miller 12:02:48 1/25/2017
- 3.7 Daniel Kindler 16:25:30 1/25/2017
- 3.8 Jason Tucker 18:38:38 1/25/2017
- 3.9 Kyle Plump 18:55:06 1/25/2017
- 3.10 Brett Schuck 19:28:39 1/25/2017
- 3.11 Damani Brown 19:47:08 1/25/2017
- 3.12 Spencer Cousino 20:33:50 1/25/2017
- 3.13 Ariella Hanna 21:39:23 1/25/2017
- 3.14 Zhenya Lindsay 22:51:56 1/25/2017
- 3.15 Jason Ly 23:40:50 1/25/2017
- 3.16 Gabriel Larson 23:47:56 1/25/2017
- 3.17 Raj Patel 0:05:56 1/26/2017
- 3.18 Timothy Smith 0:16:11 1/26/2017
- 3.19 Kyle Legters 1:05:21 1/26/2017
- 3.20 Chevaughn Berry 2:09:42 1/26/2017
- 3.21 Emily Hanna 2:10:19 1/26/2017
- 3.22 Paul Davis 2:20:22 1/26/2017
- 3.23 Ben Kristofic 2:24:36 1/26/2017
- 3.24 Michael Zheng 2:46:29 1/26/2017
- 3.25 Michael Smith 2:46:47 1/26/2017
- 3.26 Timothy Platts 3:57:45 1/26/2017
- 3.27 Christen Reinbeck 4:34:11 1/26/2017
- 3.28 John Ha 4:37:36 1/26/2017
- 3.29 Colin Schultz 8:54:00 1/26/2017
- 3.30 Anthony Tummillo 8:58:26 1/26/2017
- Basics of Event Handling, Dan Olsen, Chap 4. of Developing User Interfaces.
Ariella Hanna 11:27:55 1/23/2017
I thought this was a really important reading for designing mobile applications. Being user friendly and intuitive is essential for any application's success. You could design an app that does something revolutionary, but no one will use it if it's too difficult to use. I think the book could be updated with more modern examples than landline phones, but ultimately it was very relevant to software engineering.
Chad Pongratz 13:52:50 1/24/2017
The communication between parts is essential for understanding the interactive software that is android applications, and as such, can be used to solve a variety of problems such as closing the window by clicking the exit button, or moving the window by dragging its title bar, etc. Android applications utilize a windowing system which combines the software services to allow programs to create and organize windows as well as to implement interactive fragments within those windows. Most of these systems provide built in interactive objects such as text boxes and buttons. It is important to assign IDs to windows as they are referenced by many parts of the software. There are different variations of this windowing system as in X Windows, NeWS, and Java. As a user interacts with the input devices, these actions are translated into software events that get distributes to their appropriate windows. Input events could consist of mouse-events, modifiers, double-clicking, etc. right down to events causes from managing the window itself. Windowing systems provide a redrawing utility that will resend a rectangular block that is to be redrawn on the view as should occur via an event. Of course, this means that events must be handled as when having determined which window should receive a given event, one must be able to tie the application code to those events.....This reading was beneficial in gaining knowledge about the windowing systems used by android applications as well as events and event handling as to show how objects connect and interact with one another. I learned how events are used as the primary mechanism for communication between the user and interactive objects, and among the interactive objects themselves. I thought it was good to have read this article as it clearly articulated material such as how objects cooperate to make up an interactive application that the user is in control of where there is no uniform work flow.
Jonathan Hanobik 16:15:59 1/24/2017
I thought that this reading of event handling and interactive systems was really interesting and really vast. I have always had some idea of programs and applications working in this way, but I was definitely enlightened by some of the examples in the text. One comment I will make is that, while I understand the main idea of the chapter and the points it makes, I was a little confused with all of the different implementations and types of communications. Finally, I will say that I think that us programmers take many things for granted. While the author was describing how to implement certain functionalities and events, I realized the complexity of a simple action, like BUTTON_CLICK. All in all, this article opened my eyes to event handling and the many varieties of it that exist.
Louis Seefeld 18:59:18 1/24/2017
A lot of these systems seem to be outdated, as I have never heard of them, and some of the input keys have been depreciated. I think that event handling might be done quite differently now, although the core goals are pretty much the same. It is interesting to see the challenges that early developers had to tackle, but they may not be super relevant anymore.
Vivien Chang 19:42:50 1/24/2017
This chapter was a bit long, but it was a nice overview of the windowing system and event handling. It was interesting to learn how important communication among objects that cooperate to make up an interactive application is for this kind of software. Additionally, reading up on the different kinds of events was nice; this information be good to keep in mind when developing apps in the future.
Nick Miller 12:02:48 1/25/2017
Focused on how services are performed by systems and how interactive applications work within them. You can use windowing to break a screen into semi-independent fragments. There are many different events that need to be handled when dealing with an app. Applications need to be designed to be able to handle resizing. Handling communication can be quite simple in one-way but can get more tricky. This covers the primary basics for communication and how interactive objects organize themselves.
Daniel Kindler 16:25:30 1/25/2017
I found the reading to be very informative on UI, or user interface. After using computers for so long, many aspects of UI seem to be very obvious to us. However, we should be reminded that these choices were not so obvious to the creators. A great deal of care and detail had to go into designing aspects of UI that we are familiar with today to ensure the best overall UX, or user experience.
Jason Tucker 18:38:38 1/25/2017
This reading was more of a hands on approach to programming in android. It goes over subjects that necessary to learn in order for one to be able to build an app. It mostly goes over event handling, which apps certainly need to incorporate.
Kyle Plump 18:55:06 1/25/2017
I already know some about event driven applications from other classes offered here at Pitt. It's also very obvious why this is important to mobile applications (almost all require user input to function). I liked how in-depth this piece went - bringing up historical context, windowing systems, etc. Overall I thought this was a bit long.
Brett Schuck 19:28:39 1/25/2017
I like how in this chapter the author uses frequent subtitles to organize the material in more bite-sized pieces, making it easier to understand. I also found the diagrams very helpful. Especially the window trees, which help to illustrate the hierarchy of the windows anatomy.
Damani Brown 19:47:08 1/25/2017
This reading took a closer look at events, and their use as a communication tool between users and interactive objects such as widgets. It also talked a lot about different systems in the past, and the challenges they faced when it came to UI. The most important takeaway from this reading is knowing about the general structure of the GUI. Most windows are organized in a tree structure, and events allow user input to interact with the different windows.
Spencer Cousino 20:33:50 1/25/2017
I found today's reading to be incredibly technical. It really broke down a lot of features and ideas I feel we take for granted in today's system. For example, the windowing system was interesting to read about, since it is a feature I normally don't give any thought to.
Ariella Hanna 21:39:23 1/25/2017
This was a good recap of the history of windows and the evolution of event-handling. In the earlier CS courses, we mostly interacted with users by choosing when they were allowed to give input and only accepted text. Realistically, applications need to be able to accept input at any time in the form of events. This is especially important on mobile devices , which can have as few as zero physical buttons. It is essential that every app we create in this class handles events correctly and intuitively.
Zhenya Lindsay 22:51:56 1/25/2017
It was interesting to learn on much deeper level how event listeners work and how important they are for gui applications. Particularly, how they work in the OS windowing system, what algorithms are used for their implementing, etc. It's also made me wonder how new types of events are handled. For example, does my iPhone always listen to my surroundings to make sure it catches when I say: "Hey, Siri!"?
Jason Ly 23:40:50 1/25/2017
This reading went into detail about several different events and how they interact with one another. Also, providing the benefits and drawbacks of each model which will become useful when considering how to format or approach my future applications. I have never used a Mac before, so it was interesting to read about different implementations and challenges when trying to utilize certain events such as mouse events and double-clicking.
Gabriel Larson 23:47:56 1/25/2017
the idea behind windowing is very interesting! being able to split the screen into semi independent programmable fragments seems way over my head but the article/chapter does a good job of bringing it down. it goes on to talk about a bunch of different input devices and events and the uses of them all. then into the windowing events which again feels over my head.
Raj Patel 0:05:56 1/26/2017
This reading dealt with the fundamentals of event handling. It discusses definitions and implementations of window events, both on Windows and Mac OS's. The reading was also educational in describing the communication between events, such as using simple callback models and parent notification models.
Timothy Smith 0:16:11 1/26/2017
After reading the article, it made me more aware of the importance of events, and the issues that surround them like partitioning between the application and the windowing system, the kinds of events, distributing inputs, and models for communication. The reading covered a lot of what we went over in class, and expanded upon a lot of the subjects as well. I learned a lot about the various events that could take place like pushing a button, or moving a mouse, and what needs to happen when those events take place. Overall, it was a good in-depth overview of event handling, and it will be useful to know these methods for future projects.
Kyle Legters 1:05:21 1/26/2017
Basics of Event Handling was a very useful article to read. It dove into the depths of all of the different types of action events. This included window events, redrawing, dispatching, and much more. This article will be very helpful in my future as a programmer.
Chevaughn Berry 2:09:42 1/26/2017
Events drive the communication between users and objects within a graphical user interface. Generally the most important interaction between the user and interface comes in the form of input. The windowing system in place works to organize and manage the different window elements that are occurring at the same time in the interface. The interactive objects of the interface also communicate however the user is in control of these interface designs.
Emily Hanna 2:10:19 1/26/2017
This reading focused on event driven UI and the issues and problems that have arisen and been solved as the style changed from models where the program was in control to models where the user had control. The issues mainly were around communication and input/output and how to handle this. The reading went on to talk about the windowing system implemented in many interfaces which deals with the placement and sizing of windows through the window manager and the interactivity and software services for different programs. The interaction between the user and the windows are considered events, the most important of these typically being input events. Lastly the reading goes on to discuss interaction and communication between different objects in the windowing system such as the page moving as the scroll bar is moved.
Paul Davis 2:20:22 1/26/2017
This was an impressive article that really went into depth about the mechanics of ui design. There is a lot more that goes into ui design that it may seem. It focuses a lot on the mechanics of event handling, and the many different events that need to be monitored to provide an appropriate response. It also talked a lot of how to construct the layout of mechanically handling events. It was really interesting, and helped me think about the bigger picture, and prepare for further discussion.
Ben Kristofic 2:24:36 1/26/2017
I like how this article talked about the concept of event handling from any applications of event handling, not just for Android app development. For any UI programming where a user will be present and inputting information into a program, there are countless events that need to be listed for and handled. I thought this reading did a great job of explaining how to look out and prepare for many of these events that we might encounter while programming.
Michael Zheng 2:46:29 1/26/2017
I never really thought about how much went on behind the scenes even for a seemingly insignificant input and how many events are handled as a result. the example that stood out the most to me was the vertical scroll on mouse click. it helped me see a new perspective on the complexity of an interactive system architecture, yet how intuitive it remains for the user.
Michael Smith 2:46:47 1/26/2017
It is interesting to see how computer human interaction has evolved from simple text interfaces to complex Graphical User Interfaces. I hadn’t realized how many ways of input and the variety in events and methods of communication existed. Everything we see on a modern day computer has layers of abstraction that hides all the details of communication and execution in and between the interactive objects. I would’ve thought the loop in the main program for a GUI would’ve been more complex.
Timothy Platts 3:57:45 1/26/2017
This was a ton of content, and what I managed to read while also finishing my project was very informative. Obviously, events are the main way that users can communicate with the different views we put into out apps, and getting used to onClickListeners in our first assignment was very helpful in understanding how this all works.
Christen Reinbeck 4:34:11 1/26/2017
The universality of graphical user interfaces is what makes them (relatively) easy to use for even a first time user. The user's expectation of a cause/effect relationship between components is the foundation upon which an application is built. In order to have this relationship, one must thoroughly understand event handling. Click events, mouse movements, keyboard events, are just some of the types that one can use.
John Ha 4:37:36 1/26/2017
The reading basically talked about how the programmer develops the window with multiple functionality based on the fragments. And then there are multiple events that can be controlled by various input methods that we had to decide. Afterwards, it goes over the link with Java and how it implements object oriented app development.
Colin Schultz 8:54:00 1/26/2017
This reading helped me to better understand what events are and how they work. I can wrap my head around anroid development a little easier now. Also, I didn't really know much about the main event loop, but know I do.
Anthony Tummillo 8:58:26 1/26/2017
This chapter really expanded my own mental model of interactive software. It was eye opening to have the conceptual model of a Graphical Interface be explained as a structure which is organized into trees of windows. Reading this chapter was the first time I fully appreciated (thanks to the author) that the majority of code in a graphical application is dedicated to event handling, and that as a result the user has complete control of the control flow of the program and not the programmer. This realization seems like it should be obvious but for some reason it did not fully click for me until I had the paradigm of graphical interfaces and event-handling broken down to such a detailed granularity.