History and Overview - Mobile Applications

From CS1635 Spring 2014
Jump to: navigation, search

slides

Contents

Readings

  • Chapter 1&2 of Programming Android, By Zigurd Mednieks; Laird Dornin; G. Blake Meike; Masumi Nakamura, OReilly Press, (free online version within the campus network, you can also order a paper copy from amazon.com) (backup link in pdf format).
  • Online version can also be accessed through sremote.pitt.edu (Pick one of the links provided and then edit the URL to cs.pitt.edu and navigate from there.)


Robert McDermot 2:01:48 1/8/2014

Chapter's 1 and 2 of Programming Android talk about setting up the basics needed in order to write your first application. Chapter 1 goes through a step by step of setting up your environment with Eclipse and the ADT. Chapter 2 talks about the basics of Java as a language; the way it works, how it is different from other languages, and the basic APIs needed for any Java program. There was not much new information for me in these chapters. I already had my computer set up with an Android development environment and have successfully used it in the past to write and package an Android application. Also, I am very familiar with the basics of the Java programming language having used it for many projects, both school related and personal, in the past.

Ryan Ulanowicz 15:30:44 1/8/2014

Today's reading mostly dealt with setting up a developer environment for Android in Eclipse, and giving a basic overview (hopefully refresher) on Java. We read about downloading and installing the requisite software so that we can easily write, compile, debug, and run an Android app on a computer. After that we were given a rundown of key OO programming techniques and terms along with Java specific information such as Garbage collection. These two chapters lay a foundation for creating our own Android applications going forward.

Steven Bauer 16:18:17 1/8/2014

The first chapter was great in that it made installing the android SDK really easy. Its really cool that the SDK contains the emulator so you can easily test your code without having to push it to a physical device. The second chapter was a useful refresher on Java, although I have used Java for years here at Pitt it was nice to have a refresher on how to do synchronization. I hope that the next chapter delves more into how to use the provided android UI framework.

Sara Provost (stp28) 16:59:14 1/8/2014

I thought that the reading was very informative. The instructions on how to set up the SDK and the IDE were helpful. I also appreciated the section on how to go about setting up and beginning to create a project. The section on how to set up an emulator was helpful and informative. I also found the second chapter on Java programming to be a good review of concepts that have been covered in previous classes.

David Grayson 17:44:03 1/8/2014

Chapter 1 of Programming Android begins with outdated and somewhat useless information this late in a computer science career. I already have a JDK installed on my computer, which is a higher version than the one listed in the text, and the Android SDK now comes with a preconfigured version of Eclipse for use developing Android applications. The real meat of chapter 1 was in developing the first simple Android application, which was useful in learning about activities and running projects using the Android virtual device (since I use an iOs device). Chapter 2 of Programming Android begins with a basic review of java typing and classes; a useful review of syntax with good examples of some errors to avoid. One place I identified as a potential for outside, independent research is Java threading; I am familiar with threading in C but not in Java. Interestingly, I learned more about parsing web pages from the exception handling section than I did about exception handling. By far the most notable section of this chapter was the section on anonymous classes. I am familiar with event listeners in other languages and am thankful to know how to use them now in Java. This chapter is packed with information and will certainly require more than one read-through.

Guoyang Huang 19:40:15 1/8/2014

In chapter 1, I’ve learned the basic setup on how to create Android projects and some miscellaneous SDK tools that may be helpful later on. The chapter used Eclipse IDE with Android SDK to first create an android application project. From that example code, one can test if the person has set up the SDK correctly by using an AVD. This allows for the developer to emulate a device with ARM CPU running Android OS for the project to be tested on. One can have multiple AVDs with different attributes. What struck me the most was the use of QEMU as the virtual machine to run the emulation because I had only used QEMU for Linux OS. Additionally, another important aspect of developing is checking for the latest updates for SDK, ADT, and Eclipse. In Chapter 2, I’ve learned the simple Java usages in Android. One of the most intriguing things was the care for energy efficiency for mobile developers. In this chapter, Java for desktop application is very similar to the mobile application. It includes the primitives, classes, objects, constructors, etc. that I learned about in the previous CS classes. The new concepts that I learned were the hashCode, equals with reflex, symmetric, transitive or consistent, clone and finalize methods that I had never encountered but seem very useful. The chapter also gave a review of the Java concepts I learned in CS401, CS445 and CS1501 such as Hashmap, Collections, and Encapsulation. One new concept I’ve learned is multithreaded usage in Java because I’ve only done this with C. Chapter 2 gave a good review of the Java concepts I’ve already learned in my classes.

Guoyang Huang 19:40:20 1/8/2014

In chapter 1, I’ve learned the basic setup on how to create Android projects and some miscellaneous SDK tools that may be helpful later on. The chapter used Eclipse IDE with Android SDK to first create an android application project. From that example code, one can test if the person has set up the SDK correctly by using an AVD. This allows for the developer to emulate a device with ARM CPU running Android OS for the project to be tested on. One can have multiple AVDs with different attributes. What struck me the most was the use of QEMU as the virtual machine to run the emulation because I had only used QEMU for Linux OS. Additionally, another important aspect of developing is checking for the latest updates for SDK, ADT, and Eclipse. In Chapter 2, I’ve learned the simple Java usages in Android. One of the most intriguing things was the care for energy efficiency for mobile developers. In this chapter, Java for desktop application is very similar to the mobile application. It includes the primitives, classes, objects, constructors, etc. that I learned about in the previous CS classes. The new concepts that I learned were the hashCode, equals with reflex, symmetric, transitive or consistent, clone and finalize methods that I had never encountered but seem very useful. The chapter also gave a review of the Java concepts I learned in CS401, CS445 and CS1501 such as Hashmap, Collections, and Encapsulation. One new concept I’ve learned is multithreaded usage in Java because I’ve only done this with C. Chapter 2 gave a good review of the Java concepts I’ve already learned in my classes.

Brett Lilley 19:43:35 1/8/2014

Although I installed the Android SDK bundle from the website, and was able to get a basic program running with and AVD, I still don't actually know if I am doing the correct thing. Chapter 1 was fairly confusing describing the setup needed to have all the proper tools/IDE/APIs up to date and running. Chapter 2 was more straight forward. The chapter did a good job of conveying exactly what the intro paragraph described: the use of java within android, a side of java completely new to me. I believe that this was a good introduction to programming in android with java.

Max Campolo 20:11:16 1/8/2014

Max Campolo Critique – Reading 1/9/13 This reading covered the basica for Android programming, including installing the SDK, Java for android, using the Eclipse IDE and exporting an application for submission to the Google Play app store. Before reading Chapter 1, I had already performed the required requisites for setting up the Android environment. I have installed the android SDK up to the current version and I have experience using the Eclipse IDE for programming android applications. Exporting an application using the Eclipse IDE is pretty straight forward, only having to use the export tool built into the Eclipse IDE. Once the application has been built and tested for working functionality, it can be submitted to the Google Play app store for download by users. Covered in chapter 2 is the Android Framework, including building a view and using activities and fragments to build a working user interface. They also cover building with graphics and handling data. These are also familiar topics to me using the Eclipse IDE for development. Making a new activity class is the same as making a new Java class in eclipse. Drawing graphics is important for the user interface as well, especially animations which makes the interface smooth and interactive for the user. In order to handle persisting data, there are API’s to access the phone’s internal and external memory. Also, an active network connection can be used to store and retrieve data from a remote location. Lastly, with all of the Android devices available in the consumer market, it is important that an application supports all different devices so as many users as possible have access to the app. Instead of testing on all of the possible hardware devices which might be difficult, emulators can be used to quickly and easily be used to test the app on different platforms and devices.

Cody Giardinello 20:17:02 1/8/2014

Today's reading was very interesting. I thought the process to get a simple "Hello, world!" app ready to go was quite lengthy. Also, the emulator seems to be a neat way to program, test, and debut a mobile application. Overall, the reading was very enlightening.

Guh6 20:22:55 1/8/2014

In chapter 1, I’ve learned the basic setup on how to create Android projects and some miscellaneous SDK tools that may be helpful later on. The chapter used Eclipse IDE with Android SDK to first create an android application project. From that example code, one can test if the person has set up the SDK correctly by using an AVD. This allows for the developer to emulate a device with ARM CPU running Android OS for the project to be tested on. One can have multiple AVDs with different attributes. What struck me the most was the use of QEMU as the virtual machine to run the emulation because I had only used QEMU for Linux OS. Additionally, another important aspect of developing is checking for the latest updates for SDK, ADT, and Eclipse. In Chapter 2, I’ve learned the simple Java usages in Android. One of the most intriguing things was the care for energy efficiency for mobile developers. In this chapter, Java for desktop application is very similar to the mobile application. It includes the primitives, classes, objects, constructors, etc. that I learned about in the previous CS classes. The new concepts that I learned were the hashCode, equals with reflex, symmetric, transitive or consistent, clone and finalize methods that I had never encountered but seem very useful. The chapter also gave a review of the Java concepts I learned in CS401, CS445 and CS1501 such as Hashmap, Collections, and Encapsulation. One new concept I’ve learned is multithreaded usage in Java because I’ve only done this with C. Chapter 2 gave a good review of the Java concepts I’ve already learned in my classes.

MJ McLaughlin 20:56:26 1/8/2014

One point about Android and the Android SDK that has always been really interesting to me is how it brings a diverse set of pretty common, industry-standard tools, such as Java, XML, Eclipse, and so on, together to do something very unique and powerful. Alone, each of these tools have their own great uses, but together they have helped create a very open, innovative, and huge ecosystem of developers, users, and, excitingly, users who can become developers. These tools are very accessible and allow most anyone to pick them up, learn, experiment, and create pretty remarkable things. And this all goes back to the pretty remarkable SDK itself. I find it really incredible that the very same programming languages that are taught as introductions to computer science, languages like Java and C++, can be taken and combined with other accessible tools including markup languages, device emulators, and a diverse and helpful online community to do some amazing things. The experience of interacting with your first app on an actual device using input methods like touch screens and motion sensors is something special, and all of that is made possible through the unique tools that come together to form the Android SDK, as well as the exceptional community that has sprung up around it. On a more reading/code-related note, I also find it interesting how the reading is able to easily intertwine talking about Java in general as well as Java in relation to Android. This can be seen in such instances as how the implementation of Android packages shares a lot in common with Java packages, or how anonymous classes are useful in handling touch and click events. And best practices for Java and Android seem to have a pretty significant impact on each other, with concepts like proper multithreading and unique user interactions that play a key role in Android devices seeming to have an impact on the Java language on which the SDK itself is based. This is similar to how some Android kernel developments have been merged into the Linux kernel on which the Android kernel itself is based, and that’s really pretty cool. Java and Android can be used together to do some amazing things, and I’m excited to see what we will do in the semester to come.

Chris Solis 22:12:27 1/8/2014

Chapter 1 was an easy to follow instruction section that detailed the process of downloading different IDE's for different operating systems that will run the JRE and help with writing android applications. It mainly focused on Eclipe and the process of downloading eclipse, the android SDK, and the Android Developer Tool plug-in for Eclipse as well. It also explained the process to download the emulator and Android Virtual device which allows programmers to easily create and run android applications on their computer instead of on their phone for easier debugging. The second chapter seemed to be a overview of the basic tenets of java programming with a more focused approach towards writing java code for android applications. The first few sections explained basic concepts such as primitives and objects.Some sections tried to highlight the importance of coding with a direction towards mobile programming. For example, in the final and static declarations section they emphasized the importance of using final for the string class to make sure that a SQL injection is prevented. This prevents users from creating a mutable subclass of string and harming your application. The book also acknowledges the importance of battery life. Smart phone already have extremely fast processing speed compared to full fledged computers decades ago. However, their batter is limited to great importance must be placed on energy efficiency when programming for the mobile environment. Another android focus was in the exceptions section. We have already learned how to write try catch blocks and handle exceptions but the section outlined some special exceptions for android applications such as a NetworkException. It also explained in detail how to handle some of these exceptions to make sure that if one occurs the program does not continue. The following sections outlined different collections withing the Java Collections Framework for objects already represented in java packages. It also dissuaded us from using out data classes such as Vector and Hashtable. This provides us with easy access to the classes and packages we've already learned to use in class. The remaining sections touch on more tenets of java such as garbage collecting, scope, and java packages and multi-threading. The remaining sections also emphasized access modifiers such as private, public, and protected and the importance of acknowledging the difference between them. This is important for programming in the mobile environment because it's important to separate private data, that the user is not suppose to be aware of, from public data.

Charlie Koch 22:25:38 1/8/2014

I find it interesting and somewhat relieving that Android uses Java. It seems like it will be an easy and fun process to learn Android programming!

Nicholas Amoscato 22:31:22 1/8/2014

About a year ago, I had intentions to build an Android app, but I did not actually see that project through. However, I did install the necessary SDKs and Eclipse developer tools. Thus, installing the Android SDK this time around was nothing more than updating Google APIs and the Eclipse ADT Plugin. I did run into a few issues while upgrading, but this was resolved by reinstalling the ADT Plugin. Overall, the first chapter of "Programming Android" was relatively thorough and easy to follow. Despite the fact that I am comfortable with Java, I enjoyed reading through the second chapter of "Programming Android". It has been a while since I have read through fundamental language concepts, and it was interesting to see what was now obvious and what I had forgotten. Although I have used anonymous functions in JavaScript on countless occasions, I was unaware of the anonymous class concept in Java. Similarly, I have never utilized the low-level Java Thread object despite my knowledge of multithreaded programming.

Zhanjie Zhang 22:47:24 1/8/2014

For today's readings, I read Chapter 1 and 2 of ProgrammingAndroid. I was able to successfully follow the directions and set up the plugins and settings in Eclipse. I was also able to run a simple hello world program through the use of an emulator. Chapter 2 was a review of Java which I read and practiced on my newly developed Android application on Eclipse.

mao73 22:54:03 1/8/2014

The first chapter could probably be noted in class that it is somewhat dated. If you look at the Android SDK website, there is a bundle that you can unpack and run immediately. It has the android libraries, with the Android ADT plugin and Eclipse ready to run right away. It could save potentially an hour or so of downloading and installing the various parts for Eclipse to get up and running. The second chapter was very informative just to get a refresher in Java. Sometimes, it's frustrating to go looking through your old Java books just to find out something simple. Its good to have the quick refresher in this book which can get a programmer working faster again without having to go through each topic of a language.

James Devine 23:10:08 1/8/2014

The first chapter of the reading is dedicated to teaching the reader how to install the Android SDK and also how Eclipse can be used to build android applications. This walks the reader through the set up process of downloading eclipse, adding the necessary plugins, and also running an application by using the Emulator. The reader is introduced to the ADT Eclipse Plug-in, with explanations given for some of the main tools that will be used when building an Android application. Chapter 2 gives an overview of the Java programming language and how it is used in Android programming. The chapter touches on most of the main features of Java without going into too much detail, for that is not the purpose of the chapter. Code samples are provided to further illustrate how Java can be used to develop applications. Overall, this chapter gives a good explanation of the significance of the Java programming language.

Matt Landram 23:11:06 1/8/2014

The reading was very helpful with learning the ins and outs of the Android SDK, It'll be good to have in case I'm confused with how to use a certain feature in the future as it explains them well. Chapter 2 served as a nice refresher with Java's basic features as well.

Hao Zhang 23:12:14 1/8/2014

The chap 1 of Programming Android teaches us how to download and install Android SDK, Android environment and some related software base on different operating systems. It also teaches us how to use eclipse create a project for android, how to use some basic functions (for example how to use AVD) and how to set parameters. And chap 2 introduces JAVA, the most popular language for coding Android software, to us. It’s about the base JAVA form and skills. At the end it talks about some interface, Synchronization and Data Structures in Android programming. For me, I am familiar with writing background codes, but I don’t know how to construct UI such as insert vidos, photos or musics, change colors and buttons arrangement. I don’t know the initial device of mobile system. There are a lot of thing I need to learn in this course. In future I want to be a professional mobile app designer.

Brian Kacin 0:09:20 1/9/2014

I am at my house 20 miles off campus. I went thru PittCat on sremote, clicked on the book and it says, Page Not Found. I will try to read it on campus tomorrow (1/9 at 12pm) and give a critique before class.

Chapter 1 was nothing too crazy, just helped with the steps of installing the Android SDK and Eclipse. Chapter 2 was a very helpful refresher in Java and outlook on things to come in future assignments. Overall I am excited to start assignments in this class and to learn!

Brian Kelly 0:10:35 1/9/2014

Chapter 1 contained a very detailed list of how to set up the Android SDK and work with Eclipse's ADT plugin to begin developing Android mobile applications. It gave lots of information on AVD's. The author mentioned AVD's in three distinct sections which I thought was a bit strange. Some of the more useful information came later in the chapter where it told you about the layouts for the interfaces and the manifest files and how they are written in XML. It also mentioned helpful supplemental tools like SQLite and Draw9patch. Chapter 2 was all about Java and most of it reminded me of my introductory programming classes. It told about things like primitives, objects, classes, inheritance, polymorphism, and interfaces. Then it mentioned useful collections like lists and sets and how to use them with iterators. Then it diverges from generic Java information and focuses on things that will help with Android development. This includes the use of Java packages, anonymous classes, and multithreaded concurrent programming. These three sections especially were useful since I haven't learned about them previously. Overall, most of it was a review but of those things that were new, it was able to provide lots of details for me.

Megan Ziegler 0:12:15 1/9/2014

Today's reading was fairly straightforward. For me, about 75-80% of the java information was review, but it was still thorough and an excellent refresher. I also have the Android SDK installed and running on my computer now, so I believe I am fully ready for this course.

Zach Liss 0:21:32 1/9/2014

So today's reading wasn't too dense. We read about setting up the Android SDK with Eclipse and some basics of Java. I'm excited to have the environment set up to begin developing some mobile android applications. I already followed the first tutorial to set up my first project

Ariana Farshchi 0:28:17 1/9/2014

Chapter 1 of Android Programming, was an easy start- just installing and beginning to learn the in’s and out’s of the android developer. It was a little confusing at first though, because the ADT Bundle already comes with Eclipse, whereas the book was saying you must download it separately. Chapter 2 started out explaining that because the mobile environment is unlike a computer environment, programming in Java is different. This is because there is more things to take into account- such as different display sizes, tough screen, text input, power, etc. This chapter is mainly a review of Java. It talks in detail about Java types- primitives and objects. It explains objects and creating classes, along with inheritance and polymorphism, exceptions, interfaces, garbage collection and so on. This chapter was a good overview of Java, and helped to review and fill in some blanks.

Xiaoxuan Chen 0:48:43 1/9/2014

The first chapter talked about how to install Android SDK and set up ADT Plugin with SDK Manager. As well as configurations and gives directions on how to start a new project using Eclipse with detailed introductions on each elements. We should always keep the SDK, Eclipse, ADT plugin and JDK up-to-date for best performance. Chapter 2 introduced Java for Android, which gives a generic overview of Java, including primitive types, objects and classes, methods, inheritance, polymorphism, final/static declarations, abstract classes, interfaces, exceptions, collections framework, scopes etc. To me, these serves as a review for Java programing on Android platform.

Kyle Tanczos 1:41:00 1/9/2014

The readings were very informative. While a lot of the java explanation I had developed from previous core classes, its always good to brush up on topics that aren't repeated as much in other classes: such as encapsulation and thread management. The explanation of the SDK and eclipse setups were helpful also in getting a basic "hello world" going because I have never used Android before.

Christine Lim 3:04:29 1/9/2014

I thought the reading was a good introduction to using the Android SDK. I ran into some trouble when trying to use the emulator, though it may just be a problem on my end. I also thought the second chapter was a good refresher for the basic concepts needed to program in Java..

Pedro Alvillar 3:30:49 1/9/2014

The first chapter in Programming for Android contains detailed instructions in setting up the Android software development kit to go along with your chosen IDE. This chapter also goes on to talk about how to create a new Android project as well as how to test it using either a virtual device or an actual physical smartphone running android; other important features that are discussed within this chapter include that of the android layout manager, which provides an easier and faster way to edit layouts to desired specifications. It is very important to periodically check for updates in the SDK as newer versions are quickly coming out, while it is also equally as important, though less frequently needed, to check for updates for your IDE, and JDK. The second chapter in Programming for Android starts to talk about some of the fundamentals of Java namely : variable types, objects, classes, inheritance, polymorphism, interfaces, and exceptions. It is vital that one, as an experienced programmer, must already be familiar with these concepts in order to be capable of taking on the development of Android applications. As a mobile application developer one needs to keep in mind that there are many input streams in a mobile device, including : motion sensors, GPS units, a touch screen, and cameras. It is also important to note that as a mobile application developer, one needs to have energy efficiency as a high priority. It is equally as vital to be familiar with the idea of multi threaded concurrent programming including the huge role the synchronized keyword plays in preventing data corruption.

Alexandra Brusilovsky 9:00:07 1/9/2014

The first chapter of the reading was about installing all the software that we will need to use, and beginning to run it. It talked about the JDK, Eclipse, and Android SDK. I thought this chapter was very well written. Aside from learning how to install everything, I also learned more about how Eclipse (which I've had installed for a while) works. The second chapter was about Java. I already knew most of the information. However, this is a very good resource because it has the information all together. I learned more about Java Exceptions, which is something that got unfortunately left out of our Java education.

Zach Sadler 16:27:00 1/9/2014

The first chapter of the reading explained how to download, install, and setup the ADT with Eclipse. I plan on using Android Studio instead of Eclipse so it wasn't extremely useful, but I still followed through the steps in case my group much prefers we all use the same work environment. I found the part about setting up Android Virtual Devices to be very interesting, although it seems to be a somewhat odd interface for interacting with the virtual device. The next chapter was less useful, since it was simply a review of Java. I've been a UTA for CS 0401 four times now, so I feel very secure with the fundamentals of Java and largely skimmed this chapter. The section on threads and synchronization was slightly interesting because we don't cover those topics in Java in the core curriculum.

Cory Savit 00:00:00 1/10/2014

Chapter One talked about to to install the Android SDK and ADT plugin for eclipse. It also goes through steps on how to install the Java Development Kit, Java Runtime Environment, and Eclipse IDE but since those were already installed on my computer it wasn't very useful for me personally. When all installation and setup is finished the book walks you through a test project to make sure that your installation was successful and to give you a little hand on experience with simple Android development. I found this useful mostly because it gives some important terminology and shows you how to run programs on both an AVD and Android devices.

Chapter Two deal with Java but goes into a little more detail about how Android has become the most widely used user interface class library for Java. I found the first part interesting but most of the chapter was a review of types, classes, inheritance, polymorphism, multithreading, etc. It may not have been interesting, but it was good to refresh myself of these things since I haven't really programmed in Java for almost a year.

Buck Young 00:00:00 1/10/2014

Chapter 1: This chapter was all about getting the Android SDK and AVD up and running. This chapter was a bit outdated however it pointed me towards several useful resources on the web. Previously, I had installed all the necessary components for Android development so, for me, this was more of an updating and re-checking process. In the end, I was able to create an AVD (Nexus 7 tablet and Nexus S mobile-phone) and run my simple program on it. The emulator is a bit slow on my computer, however I found that I can attach my actual Nexus 7 tablet via USB and run the program on there! This chapter also spoke about many useful tools (many of which have been merged into the Android Device Monitor) -- I am sure to refer back to this section in the future. Chapter 2: This chapter covered the basics of the Java language. I found the initial claim very interesting: "Android is reshaping Client-Side Java." That is a very valid point! Java's web applets never really took off, however Android is the new face of Java UI's! The overall review of Java was actually very well written and highlighted all of the key points of the language... bravo! I found the review of polymorphism, generics, and the frameworks to be most useful to me. I fully intend to use this as a future reference when working in Java.

Bret Gourdie 00:00:00 1/10/2014

The first chapter of the reading was more background than anything. It had a comprehensive guide, going all the way from installing the SDK to running the example program contained within. There was also a section on troubleshooting, in case things went wrong. It also introduced the components of the SDK to explain how the whole thing was held together. This chapter concluded with a section on reading code, warning the reader that non-example code may be hard to read, but it is still incredibly useful. The second chapter provided a primer on Java, useful for the beginner diving into Android development. It covers not only the type basics, but also that of object-oriented programming, exceptions, and even the Java Collections framework. I feel these things are paramount in making any respectable mobile application so that the developer does not have to reinvent the wheel (possibly incorrectly). The chapter ends with threading and concurrency examples, which is very important as smartphones have more cores inside them, something that probably was not even considered at their inception.

Derrick Ward 00:00:00 1/10/2014

In this week’s readings were introduced into the world of Android, from the standpoint of how to configure your machine to be able to produce java applications. Chapter 1 talks a little about what Eclipse is and how to configure is to work with the Android SDK, as well as the steps to create your first or new Android project. Chapter 2 helps to give the reader a refresher on the java language. It starts with the basic knowledge of primitives all the way to some advance tips on threads. I have attempted Android programming in the past, and it did not turn out to well. By the time I wrote my first Hello World program, I became disinterested. After reading Chapter 1 and 2 of this literature, the hype seems to be back for me. Sections of chapters 2 is where I would say I found the most appreciation because I have never read about using thread in Java. Prior to this literature I had only used threads in the C programming Language.

Melissa Thompson 00:00:00 1/10/2014

These two chapters of Programming Android basically just introduce the Android SDK. We learned how to install the SDK along with the Java JDK and an Eclipse IDE. This included the basics, like setting up the build paths for the files and instaling the plug-in for Eclipse that allows for android development. These were the basics of the first part of chapter 1, so it was a bit dry, but after that the book taught us how to actually create an android project in Eclipse. I've never programmed an android application before, so the step-by-step directions helped, although it didn't seem much different than building a regular Java program. The book also shows how to use an emulator to test applications without having to use actual smartphones. The rest of chapter one was still pretty basic, going over debugging and other parts of the SDK, showing how the different components of the plug-in work and what they allow us to do, and talking about other development tools we can use. I've used QEMU before in another class, but I wasn't familiar with the other tools they talked about, although they didn't seem terribly difficult to use. The second chapter goes more into the coding aspect of programming android applications. I've coded a lot with Java here at Pitt, so this chapter was very much review for me. It went over the basics of Java: types, objects, classes, how they interact with one another, interfaces, error checking, etc. There really wasn't anything new to me in this chapter, which (while disappointing) wasn't surprising to me as a bunch of my classes have revolved around Java and I've been programming with it for years. Overall, this reading was not difficult, but I hope the other readings are a bit more interesting! It was neat learning about how to set up an android app in Eclipse, but beyond that covered basic concepts and Java coding.

Longhao Li 00:00:00 1/10/2014

Chapter 1 basically talked about the preparing work of android development. It talked about how to install the android SDK, which contain the installation of JDK, eclipse integrated android development environment and the android development Toolkit. It also talked about setting up and how to use the android virtual device, which used to run the android program. All the informations seems straight forward and useful. I can get a clear understanding on how to use these tools to write android code. Chapter 2 talked about the Java knowledge in the android development. Since android are used for mobile computing, there are some difference between the normal version Java like the limitation on the primitive types. it also talked about objects, classes, inheritance and polymorphism, collections framework, garbage collection, package, synchronization etc. Again all the knowledges are directly used in Android. I think clearly understanding of the android version Java will help developers to write code fast and robust since they will not use the methods that are not used in Java. Also some new developers who are not familiar with Java can learn how to write code for Android from the book.

Mary J. Letera 00:00:00 1/10/2014

The first chapter of Programming Android gives detailed instructions about installing the Android SDK on machines running various operating systems. It also explains some of the organization of Eclipse, including how to set up projects. There is some explanation of how to run programs in a virtual environment or an actual device hooked up to a computer. The second chapter provides oversight of Java and how it is utilized in Android. Much of the information is redundant for experienced Java programmers, but it points out special considerations that need to be made when developing for a mobile environment. The most significant takeaway from that chapter, for me, was information on synchronization in Java.