- Basics: First Start and UI
- Basics: code navigation and review, usages
- Basics: coding, code generation, intentions
- Basics: code analysis, quick-fxes & refactoring
- Basics: debugger
AppCode Basics: First Start
When you get into a new car you normally do something before you start the engine. Right?
You adjust the mirrors and seats; you check where the most important switches are and how they work. Let's quickly do the same about getting into AppCode.
On the Welcome screen you can start a new or open an existing Xcode project. All Xcode project templates are available inside the New Project wizard. To open an existing project just locate its .xcodeproj file on the disc or checkout the project from a version control system if it is not on your disc.
Here are some of the concepts of AppCode UI may want to know:
1 --- Code editors with tabs
2 --- Tool-window: specialized secondary windows attached to the bottom and sides of the workspace and provide access to typical tasks such as project management, source code search and navigation, running and debugging, integration with version control systems, etc.
3 --- Tool-window buttons: buttons that show/hide tool-windows. Numbers near window names indicate keyboard accessors, e.g. Project tool window can be accessed with Cmd-1.
4 --- Project view tool-window: a tool-window that's open by default.
5 --- Navigation Bar
6 --- Run/Debug Toolbar
These are the key UI elements you'll notice once your project is open.
AppCode is a complex and highly customizable development environment. You can quickly change the IDE look using the options under View menu or dive into IDE Settings dialog where you can configure IDE and Project settings.
AppCode allows customizing virtually anything. Walk through the Settings sections to know what you can change. To help you find a needed configuration option quickly a search field is available.
One of the important concepts of AppCode and all JetBrains products is a higher productivity via extensive keyboard use. You can do everything from the keyboard inside the IDE and you can customize the keyboard hotkeys as well. AppCode comes with 2 keymap schemes bundled: "Default" and "IntelliJ IDEA". If you are familiar with IntelliJ IDEA, you may find "IntelliJ IDEA" keymap more comfortable, while the "Default" keymap is more Mac-style.
To memorize AppCode shortcuts faster, open the keymap reference using Help | Default Keymap Reference and print it.
AppCode is also an extensible IDE. There is a number of useful plugins available. You can find them in IDE Settings | Plugins section. Review the installed plugins and those available in the repository. Note that you can disable some plugins you don't want them, e.g. you never use CVS --- you may turn it off.
NOTE for Vim addicts: If you want the powers of both worlds, Vim editing capabilities and AppCode code knowledge and others, install the 'ideaVim' plugin and enjoy!
- Open Xcode project / New project
- UI structure, customization
- Keyboard vs. mouse
- IDE/Project Settings
- Keymap (Cheatsheet), ideaVim
AppCode Basics: Code Navigation
Efficient project code navigation is critical, and it is one of key areas we focus on in creating the AppCode IDE. However, since no two projects are alike, and each developer has their own habits and practices, we have designed different sets of navigation commands to suit both keyboard addicts and mouse maniacs. Choose what's right for you, but consider checking the other options, too.
When working on your own project, you often know which file or class you want to open and edit. The fastest way to do this is to use Go to Class... (Cmd+O) or Go to File... (Cmd+Shift+O).
If you know precisely, that you want to get to a definition of MyFavoriteVariable, use Go to Symbol (Cmd+Shift+O)
Quickly navigate through class hierarchy using the gutter navigation icons:
- Go to implementation or super-class
- Switch between implementation and declaration
- Go to related files/classes
- Go to super method in interface/protocol
Other options include:
- Go to symbol
- Go to declaration
- Go to line
- Go to next/previous method, etc.
Just open the "Go To" menu and you'll see the whole list with their keyboard shortcuts. These are the options that are worth trying and remembering and that you'll need daily, if not hourly.
In addition to just navigating the code tree AppCode offers advanced code view and search options.
The specific views include:
- Project View --- main project and project files browser
- Structure View --- displays the structure of a file in the current editor tab
- Hierarchy View --- allows to see subtypes/supertypes/classes hierarchy
All three views are shown on the below screenshot and allow to quickly navigate to the corresponding source code.
Additionally, there's a "Quick Lookup" options:
- Quick Definition Lookup --- allows to see the definition of class/function/symbol without loosing the context (see screenshot above)
- Quick Documentation Lookup --- shows documentation for an object under the carret (from Xcode)
And finally, the last in this section but probably one of the utmost importance --- Usage Search.
Thanks to AppCode's ultimate knowledge of your project code you can easily find out where some object is being used, be it a class, a function, a variable or a resource such as image file.
Just put a caret on a symbol in the editor or select a file in project view and hit Alt+F7, select where to search and see the results in a special view broken down into categories such as 'Variable declaration, Usage in Import, etc.
Alternatively hit Cmd+Alt+F7 and see the same results instantly in a popup window.
Pick a place you want to jump to and hit Enter to open it in the editor.
- Go to file/class/symbol (not just Obj-C, but JS, HTML, CSS too)
- Gutter (Go to implementation/super-class, Implementation > declaration)
- Cmd-Alt-B - all subclasses (implementations). Yellow --- from standard library
- Class hierarchy
- Related file .h<->.m
- Quick look
- Documentation (from Xcode)
- Usage Search (classes/methods/functions/vars/resources/images)
AppCode Basics: Coding, Generation, Intentions
- No need to write . Can write calls with .
- Smart completion
- Complete statement for ; and if
- Live templates
- Surround with
- Parameters signature display (Cmd+P)
- Code transformations/intention actions
- Code formatting
AppCode Basics: code analysis, quick-fixes, refactoring
- On-the-fly error and quality checking
AppCode Basics: debugger
AppCode Basics: VCS
Separate posts ideas
Color coded files