Jirajha

No, you won't be learning much on an iPad Pro.
 
My best advice would be to not only learn how to write code. Cover these areas too:
Code standards - Learn what good code is and stick to it Frameworks - Don't try reinventing the wheel. Cover front-end and back-end Databases - You need somewhere to store data. Look at query optimisation & replication Linux - You're going to be connecting to a Linux server using SSH at some point Security - Do not forget this! Know how to write secure code, stay up to date on the OWASP Top 10 and use Encryption where necessary Software Development Methodologies Software Development Life Cycyle Testing - Unit & Functional Continuous Automation / Delivery / Deployment Version Control - Git Other Standards - e.g PHP-FIG PSRs When I'm interviewing software engineers the last thing on my mind is your ability to write code, that will be done with a test. If you can't show me you know to a decent level at least a good proportion of the points above (especially security) then it's hard to offer a position.

First, you have to understand that in programming, we have what are called subroutines or functions. A subroutine can be executed (called) and given some information to work with (parameters) and it can return a result when it's done (return value).
 
Simple example (not actual code):
Subroutine called Print_something_to_screen ( parameter: thing_to_print) { //Code that prints "thing_to_print" to screen. } Main program { call Print_something_to_screen(Hello) call Print_sonething_to_screen(World) } So we have a subroutine that prints it's parameter to screen and we call it twice from the main program, this will print "HelloWorld". Beeing able to call them over and over is one of the strengths of subroutines, if something needs to be done multiple times we don't write it multiple times, we make it a subroutine and call it multiple times.
 
A API is nothing more then a collection of such subroutines that do various things.
Why do we need API's and not write everything ourselves?
 
-Because we don't want to keep reinventing the wheel. Many common things need to happen a lot and everybody uses them. For example, reading and writing things to a file. So, most programming languages provide a API for file handling so we can just call those functions to open, read and write files.
 
-Because we're not allowed to do everything. Most modern operating systems such as windows are multitasking, many programs run at the same time. That requires programs to behave to certain rules. For example, if my program wants to read/write something to a serial port like COM1, I'm not allowed to use the port directly. Other programs might want to use it aswell or may perhaps already be using it. The windows API has functions that provide access to the serial port and windows acts as the 'referee'.
 
-Because we want abstractions. For example, deep down in the system, reading and writing to files works very differently on different systems. Under the hood, windows and linux, for example, handle files in a totally different way. Because of API's, the application programmer does not have to care. The C API for handling files, to pick one, is standardized so it looks the same on any system. That means the application programmer can always access files with the same functions without caring what system he's on.

It's a subjective question to which this is the most appropriate answer:
In general when you write software you ideally want to make each component, concern or concept in your system as decoupled as possible (coupling kills). A context specific example is that you would design your application such that you don't have to rely on any specific database technology at all. Indeed you'd want to be able to swap between database technologies whenever you'd like without having to worry about a redesign or a re-implementation.
 
With this in mind the way you would normally work towards something like that would be by choosing a database technology and then wrapping it in something like the Entity Framework or NHibernate to handle the data access. Then you would hide this implementation detail behind another interface or layer such as The Repository Pattern. This way you'd end up with a set of clean interfaces that are completely free of any implementation detail whatsoever which you can then write behavioural tests around.
 
Higher order patterns such as Model, View, VIewModel (MVVM) or Model View Controller (MVC) separate out each overall concern into it's own component or namespace. They are usually comprised of many other lower order patterns themselves and most importantly each component shouldn't care about any other. Any communication carried out between them is achieved by various patterns of abstraction such as Dependency Injection (DI) and Inversion of Control (IoC) for example.
 
All of these concepts are basic fundamentals which belong to Single Responsibility, Open-Closed, Liskov Substitution, interface Segregation and Dependency Inversion (SOLID). You may also want to look at Atomicity, Consistency, Isolation, Durability (ACID) and the Keep it Simple, Stupid (KISS principal).
 
In conclusion at the point that you seem to be at you should perhaps consider taking a step back and asking yourself: "What does it really mean?"

just post the error here, we probably will fix it for free.

Few code quality things
* Remove all the unnecessary whitespace, i.e. lines 10, 13, 16, 18 and 19
* The variable m isn't necessary at all, just pass i * t into the print function. If m was required (for example if you were using the result of i * t more than once and don't want to calculate it twice) then you should declare m inside the loop rather than putting the declaration outside the loop.
 
For making the output prettier, rather than using WriteLine you want to use a StringBuilder and append to it the number followed by a space, so you start with an empty string "", append "1 " to it giving "1 " then add "2 " to that giving "1 2 " and so on then print it at the end of the inner loop with a new line character.

Network Attached Storage (NAS) is file level storage over a network medium. Storage Area Network (SAN) is block level storage over a network medium. In general and highly simplified. Block level devices would appear as a physical disk to the server OS. 
 
NAS protocols would be NFS, SMB, AFP etc
SAN protocols would be iSCSI, FC, FCoE, iFC, SAS (when using SAS switches) etc
 
There has been a large shift, mostly driven by NetApp, to move VMware environments from block level storage and VMFS to NFS datastores. NetApp is what we have at work. We use NFS for our VMware servers, iSCSI for SQL/Exchange and SMB/NFS for file shares.

Maybe add something like this ?
String pwin;switch (winner){ case a: pwin = "p1"; break; case b: pwin = "p2"; break; case c: pwin = "p3"; break; case d: pwin = "p4"; break;}

If you are completely new to programming or have little experience I would advise against C++.
While it is nice and might be able to teach you every little detail there is about programming and yes, it is probably the most powerful language out there, you are forced to learn very much before you are actually able to do little things.
 
Currently there are two kinda default languages I know of to learn at schools and universities: Java and Python.
While I consider Java to be decently obsolete, some people will advise learning that for the easy to read and understand Syntax ( = code grammar) aswell as platform independency. Wich is certainly true.
Python gets you more to stick to conventions (things you should always do unless unavoidable even though there are other solutions) and to focus more on what is actually happening. Wich again, is certainly true.
 
You cannot use them in Unity however.
The main languages for Unity are JavaScript and C#.
JavaScript however has downfalls in performance and usability. Frameworks (libraries that have prefactored and ready-to-use code) are usually designed for use in web applications and the whole thing is strictly interpreted (simplified: realtime translation from language into machine code). I know there are ways around it but that's why I would reccommend against that aswell when it comes to desktop applications.
 
The thing left is what I would have reccommended you regardless of Unity: C#.
In a nutshell, C# is C++ with a Java Syntax.
It is almost as powerful as C++ in most desktop scenarios if you leave out high-performance applications like CAD-Software, etc.
However, it is as easy to read and learn as Java and the underlying framework ( .NET) is probably one of the most powerful ones for a day-to-day use on the market that will allow you to focus on doing things, rather than on how to do things.
If you really want platform independency, you can use MONO, wich is a platform independent and open source .NET implementation. Unity uses this aswell for its C# implementation.
It is also possible to develop Web Applications with HTML/CSS and C# or iOS/Android Apps with the help of Xamarin.
 
And compared to Java, C# has an official standard.

Think of a modular design:
You have a module that's responsible for stocks, one that is for item- and product data, one that does the connection to ebay, one for amazon etc.
 
Each module consists of it's own data structures. Each module also has it's own frontend (a form or in your case: a webpage), or a page within the frontend to be precise.
So each module typically has a table that just stores its own permissions for a user or a role.
user (user_id, user_name)role (role_id, role_name)user_role (id, user_id, role_id)role_generalPermissions(rgp_role_id, rgp_canInvoice, ...)role_StockPermissions(rsp_role_id, rsp_canAccessStockPage, rsp_canModifyStockPage, rsp_canTransferStock, ...) Another thing I have seen would be something like:
user (user_id, user_name)role (role_id, role_name)user_role (id, user_id, role_id)role_permissions (rp_role_id, rp_permissionName, rp_permissionValue) Storing each thing they are allowed to do in a new row.
Like:
rp_role_id  |  rp_permissionName  |  rp_permissionValue1                   CanAccessStuff           true1                   CanModifyStuff            false2                   CanAccessStuff           true2                   CanAccessStuff           true

Your best option would be 3 tables:
 
users roles user_roles This allows you to expand the system at a later date and assign specific roles to users. Each user then has to be assigned each role specifically.