book

Head First Android Development

by Dawn Griffiths, David Griffiths

June 2015

Beginner to intermediate

732 pages

17h 32m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Dedication
Authors of Head First Android Development
How to Use This Book: Intro
Who is this book for?Who should probably back away from this book?We know what you’re thinkingWe know what your brain is thinkingMetacognition: thinking about thinkingHere’s what WE did:Here’s what YOU can do to bend your brain into submissionRead meThe technical review teamAcknowledgmentsSafari® Books Online
1. Getting Started: Diving In
Welcome to AndroidvilleLayouts define what each screen looks likeJava code defines what the app should doSometimes extra resources are needed tooThe Android platform dissectedHere’s what we’re going to doYour development environmentThe Android SDKAndroid Studio is a special version of IntelliJ IDEAInstall JavaThen install Android StudioBuild a basic appLet’s build the basic app1. Create a new project2. Configure the project3. Specify the API levelActivities and layouts from 50,000 feetBuilding a basic app (continued)4. Create an activityBuilding a basic app (continued)5. Configure the activityYou’ve just created your first Android appAndroid Studio creates a complete folder structure for youThe folder structure includes different types of filesUseful files in your projectEdit code with the Android Studio editorsThe code editorThe design editorRun the app in the Android emulatorSo what does the emulator look like?Creating an Android Virtual DeviceOpen the Android Virtual Device ManagerSelect the hardwareSelect a system imageVerify the AVD configurationRun the app in the emulatorCompile, package, deploy and runYou can watch progress in the consoleTest driveWhat just happened?Refining the appThe app has one activity and one layoutThe activity controls what the app doesThe layout controls the app appearanceWhat’s in the layout?The design editorThe code editoractivity_main.xml has two elementsThe layout file contains a reference to a string, not the string itselfLet’s look in the strings.xml fileUpdate strings.xml to change the textTake the app for a test driveYour Android Toolbox
2. Building Interactive Apps: Apps That Do Something
You’re going to build a Beer Adviser appHere’s what you need to doCreate the projectWe’ve created a default activity and layoutAdding components with the design editorChanges in the design editor are reflected in the XMLactivity_find_beer.xml has a new buttonButtons and text views are subclasses of the same Android View classandroid:idandroid:textandroid:layout_width, android:layout_heightA closer look at the layout codeThe RelativeLayout elementThe TextView elementThe Button elementChanges to the XML......are reflected in the design editorUse string resources rather than hardcoding the textChange the layout to use the string resourcesLet’s take the app for a test driveHere’s what we’ve done so farAdd values to the spinnerAdding an array resource is similar to adding a stringGet the spinner to reference a string-arrayTest drive the spinnerWe need to make the button do somethingMake the button call a methodUse onClick to say which method the button callsWhat activity code looks likeAdd an onClickFindBeer() method to the activityonClickFindBeer() needs to do somethingUse findViewById() to get a reference to a viewOnce you have a View, you can access its methodsSetting the text in a TextViewRetrieving the selected value in a spinnerUpdate the activity codeThe first version of the activityWhat the code doesTest drive the changesBuilding the custom Java classCustom Java class specBuild and test the Java classEnhance the activity to call the custom Java class so that we can get REAL adviceActivity code version 2What happens when you run the codeTest drive your appYour Android Toolbox
3. Multiple Activities and Intents: State Your Intent
Apps can contain more than one activityHere are the stepsHere’s the app structureCreate the projectUpdate the layoutUpdate strings.xml...... and add the method to the activityCreate the second activity and layoutWhat just happened?Welcome to the Android manifest fileEvery activity needs to be declaredAn intent is a type of messageUse an intent to start the second activityWhat happens when you run the appThe story continues...Test drive the appPass text to a second activityLet’s start with the layoutUpdate the text view propertiesputExtra() puts extra information in an intentHow to retrieve extra information from an intentUpdate the CreateMessageActivity codeGet ReceiveMessageActivity to use the information in the intentWhat happens when the user clicks the Send Message buttonTest drive the appWe can change the app to send messages to other peopleHow Android apps workIntents can start activities in other appsBut we don’t know what apps are on the deviceHere’s what you’re going to doCreate an intent that specifies an actionHow to create the intentAdding extra informationChange the intent to use an actionWhat happens when the code runsThe story continues...The intent filter tells Android which activities can handle which actionsHow Android uses the intent filterYou need to run your app on a REAL device1. Enable USB debugging on your device2. Set up your system to detect your device3. Plug your device into your computer with a USB cable4. Run your app in Android Studio as normalAnd here’s the app running on the physical deviceTest drive the appIf you have one activityIf you have more than one activityWhat if you ALWAYS want your users to choose an activity?Intent.createChooser() displays a chooser dialogWhat happens when you call createChooser()The story continues...Change the code to create a chooserUpdate strings.xml...... and update the onSendMessage() methodTest drive the appIf you have one activityIf you have more than one activityIf you have NO matching activitiesYour Android Toolbox
4. The Activity Lifecycle: Being an Activity
How do activities really work?The Stopwatch appBuild the appThe stopwatch layout codeThe stopwatch strings.xml fileHow the activity code will workAdd code for the buttonsThe runTimer() methodHandlers allow you to schedule codeThe post() methodThe postDelayed() methodThe full runTimer() codeThe full StopwatchActivity codeWhat happens when you run the appThe story continuesTest drive the appBut there’s just one problem...What just happened?Rotating the screen changes the device configurationFrom birth to death: the states of an activityThe activity lifecycle: from create to destroyYour activity inherits the lifecycle methodsHow do we deal with configuration changes?Bypass re-creating the activityOr save the current state......then restore the state in onCreate()What happens when you run the appThe story continuesTest drive the appThere’s more to an activity’s life than create and destroyStart, stop, and restartThe activity lifecycle: the visible lifetimeWe need to implement two more lifecycle methodsImplement onStop() to stop the timerThe updated StopwatchActivity codeWhat happens when you run the appTest drive the appBut what if an app is only partially visible?The activity lifecycle: the foreground lifetimeStop the stopwatch if the activity’s pausedWhat happens when you run the appTest drive the appThe complete activity codeYour handy guide to the lifecycle methodsYour Android Toolbox
5. The User Interface: Enjoy the View
Your user interface is made up of layouts and GUI componentsThree key layouts: relative, linear, and gridRelativeLayoutLinearLayoutGridLayoutRelativeLayout displays views in relative positionsYou MUST set the layout width and heightAdding paddingPositioning views relative to the parent layoutAttributes for positioning views relative to the parent layoutPositioning views relative to other viewsAttributes for positioning views relative to other viewsUse margins to add distance between viewsRelativeLayout: a summaryHow you specify a relative layoutYou can position views relative to the layout of another viewYou can add margins to views to increase the space around themLinearLayout displays views in a single row or columnHow you define a linear layoutA linear layout displays views in the order they appear in the layout XMLLet’s change up a basic linear layoutHere’s the starting point for the linear layoutMake a view streeeeetch by adding weightAdding weight to one viewAdding weight to multiple viewsUse gravity to specify where text appears in a viewTest driveUsing the android:gravity attribute: a list of valuesMove the button to the right with layout-gravityMore values you can use with the android:layout-gravity attributeThe full linear layout codeLinearLayout: a summaryHow you specify a linear layoutViews get displayed in the order they appearStretch views using weightUse gravity to specify where a view’s contents appear in a viewUse layout-gravity to specify where a view appears in its enclosing spaceGridLayout displays views in a gridHow you define a grid layoutAdding views to the grid layoutLet’s create a new grid layoutHere’s what we’re going to doWe’ll start with a sketchThe grid layout needs two columnsRow 0: add views to specific rows and columnsRow 1: make a view span multiple columnsRow 2: make a view span multiple columnsThe full code for the grid layoutGridLayout: a summaryHow you specify a grid layoutSpecify which row and column each view should start inSpecify how many columns each view should spanLayouts and GUI components have a lot in commonGUI components are a type of ViewLayouts are a type of View called a ViewGroupWhat being a view buys youGetting and setting propertiesSize and positionFocus handlingEvent handling and listenersA layout is really a hierarchy of ViewsPlaying with viewsText viewDefining it in XMLUsing it in your activity codeEdit TextDefining it in XMLUsing it in your activity codeButtonDefining it in XMLUsing it in your activity codeToggle buttonDefining it in XMLUsing it in your activity codeSwitchDefining it in XMLUsing it in your activity codeCheck boxesDefining them in XMLUsing them in your activity codeRadio buttonsDefining them in XMLUsing them in your activity codeSpinnerDefining it in XMLUsing it in your activity codeImage viewsAdding an image to your projectImages: the layout XMLUsing it in your activity codeAdding images to buttonsDisplaying text and an image on a buttonImage ButtonDefining it in XMLUsing it in your activity codeScroll viewsToastsUsing it in your activity codeYour Android Toolbox
6. List Views and Adapters: Getting Organized
Every app starts with ideasCategorize your ideas: top-level, category, and detail/edit activitiesTop-level activitiesCategory activitiesDetail/edit activitiesNavigating through the activitiesTop-level activities go at the topCategory activities go between top-level and detail/edit activitiesDetail/edit activitiesUse ListViews to navigate to dataWe’re going to build part of the Starbuzz appThe top-level activityThe drinks category activityThe drink detail activityHow the user navigates through the appThe Starbuzz app structureHere are the stepsCreate the projectThe Drink classThe image filesThe top-level layout contains an image and a listUse a list view to display the list of optionsHow to define a list view in XMLThe full top-level layout codeTest driveGet ListViews to respond to clicks with a ListenerOnItemClickListener listens for item clicksSet the listener to the list viewWhat happens when you run the codeThe full TopLevelActivity codeWhere we’ve got toA category activity displays the data for a single categoryA ListActivity is an activity that contains only a listHow to create a list activityandroid:entries works for static array data held in strings.xmlFor nonstatic data, use an adapterConnect list views to arrays with an array adapterAdd the array adapter to DrinkCategoryActivityWhat happens when you run the codeTest drive the appApp review: where we’ve got toHow we handled clicks in TopLevelActivityListActivity implements an item click listener by defaultPass data to an activity using the ListActivity onListItemClick() methodThe full DrinkCategoryActivity codeA detail activity displays data for a single recordRetrieve data from the intentUpdate the views with the dataThe DrinkActivity codeWhat happens when you run the appThe story continuesTest drive the appYour Android Toolbox
7. Fragments: Make it Modular
Your app needs to look great on all devicesOn a phone:On a tablet:Your app may need to behave differently tooOn a phone:On a tablet:But that means you might duplicate codeFragments allow you to reuse codeA fragment has a layoutThe Workout app structureHere are the stepsCreate the projectThe Workout classHow to add a fragment to your projectFragment layout code looks just like activity layout codeWhat fragment code looks likeAdding a fragment to an activity’s layoutPassing the workout ID to the fragmentGet the activity to set the workout IDActivity states revisitedThe fragment lifecycleYour fragment inherits the lifecycle methodsSet the view’s values in the fragment’s onStart() methodTest drive the appWhat happens when you run the appWhere we’ve got toWe need to create a fragment with a listA ListFragment is a fragment that contains only a listHow to create a list fragmentWe’ll use an ArrayAdapter to set the values in the ListViewA Fragment isn’t a type of ContextThe updated WorkoutListFragment codeDisplay WorkoutListFragment in the MainActivity layoutTest drive the appWe need to get WorkoutDetailFragment to respond to clicks in WorkoutListFragmentWiring up the list to the detailWe need to decouple the fragment with an interfaceBut when will the activity say that it’s listening?First, add the interface to the list fragmentThen make the activity implement the interfaceBut how do we update the workout details?You want fragments to work with the back buttonWelcome to the back stackDon’t update—instead, replaceUsing fragment transactionsThe updated MainActivity codeTest drive the appRotating the device breaks the appThe WorkoutDetailFragment codePhone versus tabletOn a tabletOn a phoneThe phone and tablet app structuresOn a tabletOn a phonePut screen-specific resources in screen-specific foldersThe different folder optionsTablets use layouts in the layout-large folderThe MainActivity phone layoutPhones will use DetailActivity to display details of the workoutThe full DetailActivity codeUse layout differences to tell which layout the device is usingThe revised MainActivity codeTest drive the appYour Android ToolboxFragment Lifecycle Methods

8. Nested Fragments: Dealing with Children
Creating nested fragmentsWe’ll add a new stopwatch fragmentFragments and activities have similar lifecycles...... but the methods are slightly differentThe StopwatchFragment codeThe StopwatchFragment layoutThe StopwatchFragment layout uses String valuesAdding the stopwatch fragment to WorkoutDetailFragmentWe need to add it programmaticallyAdd a FrameLayout where the fragment should appearThen display the fragment in Java codegetFragmentManager() creates transactions at the activity lavelBeware the back buttonNested fragments need nested transactionsDisplay the fragment in its parent’s onCreate() methodThe full WorkoutDetailFragment codeTest drive the appBut there’s a problem if you try to interact with the stopwatchWhy does the app crash if you press a button?Let’s look at the StopwatchFragment layout codeThe onClick attribute calls methods in the activity, not the fragmentHow to make button clicks call methods in the fragmentFirst, remove the onClick attributes from the fragment’s layoutMake the fragment implement OnClickListenerThe StopwatchFragment onClick() methodAttach the OnClickListener to the buttonsThe StopwatchFragment codeTest drive the appBut there’s a problem when you rotate the deviceRotating the device re-creates the activityWhat happens to the fragment when you rotate the deviceonCreate() REPLACES the fragmentThe WorkoutDetailFragment codeTest drive the appYour Android Toolbox
9. Action Bars: Taking Shortcuts
Great apps have a clear structureTop-level screensCategory screensDetail/edit screensThey also have great shortcutsDifferent types of navigationUsing actions for navigationLet’s start with the action barAPI level 11 and aboveAPI level 7 or aboveThe Android support librariesYour project may include support librariesWe’ll get the app to use up to date themesChange MainActivity to use an ActivityApply a theme in AndroidManifest.xmlDefine styles in style resource filesSet the default theme in styles.xmlUse a Material theme on newer devicesWhat happens when you run the appTest drive the appAdding action items to the action barThe menu resource fileThe menu showAsAction attributeAdd a new action itemInflate the menu in the activity with the onCreateOptionsMenu() methodReact to action item clicks with the onOptionsItemSelected() methodCreate OrderActivityStart OrderActivity with the Create Order action itemThe full MainActivity.java codeTest drive the appSharing content on the action barYou share the content with an intentAdd a share action provider to menu_main.xmlSpecify the content with an intentThe full MainActivity.java codeTest drive the appEnabling Up navigationSetting an activity’s parentAdding the Up buttonTest drive the appYour Android Toolbox
10. Navigation Drawers: Going Places
The Pizza app revisitedNavigation drawers deconstructedThe Pizza app structureCreate TopFragmentCreate PizzaFragmentCreate PastaFragmentCreate StoresFragmentAdd the DrawerLayoutThe full code for activity_main.xmlInitialize the drawer’s listUse an OnItemClickListener to respond to clicks in the list viewThe selectItem() method so farChanging the action bar titleClosing the navigation drawerThe updated MainActivity.java codeGet the drawer to open and closeUsing an ActionBarDrawerToggleModifying action bar items at runtimeThe updated MainActivity.java codeEnable the drawer to open and closeSyncing the ActionBarDrawerToggle stateThe updated MainActivity.java codeTest drive the appThe title and fragment are getting out of syncDealing with configuration changesReacting to changes on the back stackAdding tags to fragmentsFind the fragment using its tagThe full MainActivity.java codeTest drive the appYour Android Toolbox
11. SQLite Databases: Fire Up the Database
Back to StarbuzzAndroid uses SQLite databases to persist dataWhere’s the database stored?Android comes with SQLite classesThe SQLite HelperCursorsThe SQLite DatabaseThe current Starbuzz app structureWe’ll change the app to use a databaseThe SQLite helper manages your databaseCreate the SQLite helper1. Specify the databaseInside a SQLite databaseStorage classes and data-typesYou create tables using Structured Query Language (SQL)The onCreate() method is called when the database is createdInsert data using the insert() methodUpdate records with the update() methodMultiple conditionsDelete records with the delete() methodThe StarbuzzDatabaseHelper codeWhat the SQLite helper code doesWhat if you need to change the database?SQLite databases have a version numberUpgrading the database: an overviewThe story continues....How the SQLite helper makes decisionsUpgrade your database with onUpgrade()Downgrade your database with onDowngrade()Let’s upgrade the databaseUpgrading an existing databaseAdd new columns to tables using SQLRenaming tablesDelete tables by dropping themExecute the SQL using execSQL()The full SQLite helper codeThe SQLite helper code (continued)What happens when the code runsYour Android Toolbox
12. Cursors and Asynctasks: Connecting to Databases
The story so far...We’ll change the app to use the databaseThe current DrinkActivity codeGet data from the database with a cursorCursors give you access to database dataA query lets you say what records you want from the databaseSpecify the table and columnsDeclare any conditions that restrict your selectionOther stuff you can use queries forThe SQLiteDatabase query() method lets you build SQL using a query builderSpecifying table and columnsRestrict your query by applying conditionsApplying multiple conditions to your queryYou specify conditions as String valuesOrder data in your queryUsing SQL functions in queriesSQL GROUP BY and HAVING clausesGet a reference to the databasegetReadableDatabase() versus getWritableDatabase()getReadableDatabase()getWritableDatabase()The code for getting a cursorWhat the code doesTo read a record from a cursor, you first need to navigate to itNavigating cursorsGetting cursor valuesFinally, close the cursor and databaseThe DrinkActivity codeWhat we’ve done so farThe current DrinkCategoryActivity codeHow do we replace the array data in the ListView?A CursorAdapter reads just enough dataThe story continuesA SimpleCursorAdapter maps data to viewsFirst, create the cursorCreating the SimpleCursorAdapterClosing the cursor and databaseThe revised code for DrinkCategoryActivityTest drive the appWhere we’ve got toPut important information in the top-level activityAdd favorites to DrinkActivityAdd a new column to the cursorRespond to clicks to update the databaseThe DrinkActivity codeDisplay favorites in TopLevelActivityDisplay the favorite drinks in activity_top_level.xmlWhat changes are needed for TopLevelActivity.javaThe new top-level activity codeTest drive the appCursors don’t automatically refreshChange the cursor with changeCursor()The revised TopLevelActivity.java codeTest drive the appDatabases can make your app go in sloooo-moooo....Life is better when threads work togetherWhat code goes on which thread?AsyncTask performs asynchronous tasksThe onPreExecute() methodThe doInBackground() methodThe onProgressUpdate() methodThe onPostExecute() methodThe AsyncTask classExecute the AsyncTaskThe DrinkActivity.java codeA summary of the AsyncTask stepsYour Android Toolbox
13. Services: At Your Service
Services work behind the scenesThere are two types of serviceThe started service appCreate the projectWe’re going to create an IntentServiceThe IntentService from 50,000 feetHow to log messagesThe full DelayedMessageService codeYou declare services in AndroidManifest.xmlAdd a button to activity_main.xmlYou start a service using startService()Test drive the appWe want to send a message to the screenScreen updates require the main threadonStartCommand() runs on the main threadThe full DelayedMessageService.java codeThe application contextTest drive the appCan we improve on using Toasts?How you use the notification serviceYou create notifications using a notification builderGetting your notification to start an activity1. Create an explicit intent2. Pass the intent to the TaskStackBuilder3. Get the pending intent from the TaskStackBuilder4. Add the intent to the notificationSend the notification using the notification serviceThe full code for DelayedMessageService.javaWhat happens when you run the codeThe story continuesTest drive the appBound services are more interactiveHow the odometer app will workThe steps needed to create the OdometerServiceCreate a new Odometer projectHow binding worksDefine the BinderGet the service to do somethingThe Service class has four key methodsLocation, location, location...Add the LocationListener to the serviceRegistering the LocationListenerStop location updates when the service is destroyedTell the activity the distance traveledThe full OdometerService.java codeUpdate AndroidManifest.xmlWhere we’ve got toUpdate MainActivity’s layoutCreate a ServiceConnectionBind to the service when the activity startsUnbind from the service when the activity stopsDisplay the distance traveledThe full MainActivity.java codeWhat happens when you run the codeThe story continuesTest drive the appYour Android Toolbox
14. Material Design: Living in a Material World
Welcome to Material DesignCardViews and RecyclerViewsfrom this:to this:The Pizza app structureAdd the pizza dataAdd the Pizza classAdd the support librariesCreate the CardViewThe full card_captioned_image.xml codeRecyclerViews use RecyclerView.AdaptersCreate the basic adapterDefine the adapter’s ViewHolderCreate the ViewHoldersEach card view displays an image and a captionCreate the constructorAdd the data to the card viewsThe full code for CaptionedImagesAdapter.javaCreate the recycler viewAdd the RecyclerView to the layoutUsing the adapterThe PizzaMaterialFragment.java codeA RecyclerView uses a layout manager to arrange its viewsSpecifying the layout managerThe full PizzaMaterialFragment.java codeGet MainActivity to use the new PizzaMaterialFragmentWhat happens when the code runsThe story continuesTest drive the appWhere we’ve got toCreate PizzaDetailActivityWhat PizzaDetailActivity.java needs to doUpdate AndroidManifest.xmlThe code for PizzaDetailActivity.javaGetting a RecyclerView to respond to clicksYou can listen to views from the adapterKeep your adapters reusableDecouple your adapter with an interfaceAdd the interface to the adapterImplement the listener in PizzaMaterialFragment.javaTest drive the appBring the content forwardThe full code for fragment_top.xmlThe full code for TopFragment.javaTest drive the appYour Android Toolbox
I. Leaving town...
A. ART: The Android Runtime
What is the Android runtime (ART)?ART is very different from the JVMHow Android runs an APK filePerformance and sizeSecurity
B. ADB: The Android Debug Bridge
adb: your command-line palRunning a shellGet the output from logcatCopying files to/from your deviceAnd much, much more...
C. The Emulator: The Android Emulator
Why the emulator is so slowHow to speed up your Android development1. Use a real device2. Use an emulator snapshot3. Use hardware acceleration
D. Leftovers: The Top Ten Things (we didn’t cover)
1. Distributing your appPreparing your app for releaseReleasing your app2. Content providers3. The WebView class4. AnimationProperty animationView animationsActivity transitions5. Maps6. Cursor loaders7. Broadcast receivers8. App widgets9. NinePatch graphics10. Testing
E. O’reilly®: Android Development
What will you learn from this book?Why does this book look so different?
Index
About the Authors
Copyright

Content preview from Head First Android Development

Chapter 1. Getting Started: Diving In

Android has taken the world by storm.

Everybody wants a smartphone or tablet, and Android devices are hugely popular. In this book, we’ll teach you how to develop your own apps, and we’ll start by getting you to build a basic app and run it on an Android Virtual Device. Along the way, you’ll meet some of the basic components of all Android apps, such as activities and layouts. All you need is a little Java know-how...

Welcome to Androidville

Android is the world’s most popular mobile platform. At the last count, there were over one billion active Android devices worldwide, and that number is growing rapidly.

Android is a comprehensive open source platform based on Linux and championed by Google. It’s a powerful development framework that includes everything you need to build great apps using a mix of Java and XML. What’s more, it enables you to deploy those apps to a wide variety of devices—phones, tablets and more.

So what makes up a typical Android app?

We’re going to build our Android apps using a mixture of Java and XML. We’ll explain things along the way, but you’ll need to have a fair understanding of Java to get the most out of this book.

Layouts define what each screen looks like

A typical Android app is comprised of one or more screens. You define what each screen looks like using a layout to define its appearance. Layouts are usually defined ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Head First Android Development, 3rd Edition

Publisher Resources

ISBN: 9781449362171Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design