iOS Developer Journey. Zmienne w Swift

iOS Developer Journey. Zmienne w Swift

W życiu prawie każdego programista pojawia się taka chwila kiedy chce poznać nowy język programowania/technologię. U mnie ten wybór padł na  Swift i ogólnie cały ekosystem związany z iOS.

Przynajmniej części z nas :). Dziś krótki wstęp i porównanie tworzenia zmiennych w Swift 4 i C# 7.

Swift C#

var firstname = „Maciej”

string firstname = „Maciej”

var firstname:String = „Maciej”

var firstname = „Maciej”

var money = 4500.00

double money = 4500.00

var money:Double = 4500.00

var money = 4500.00

var age = 20

int age = 20

var age:Int = 20

var age = 20

var isDone = true

bool isDone = true

var isDone:Bool = true

var isDone = true

Jak widać zmienne w Swift można definiować jako zmienne dynamiczne lub silnie typowane. Osobiście bardziej preferuje podejście silnie typowane gdzie wiadomo od razu jakiego typu będzie zmienna.

Również oba języki mają dużo cech wspólnych. Może nauka nie będzie taka straszna 🙂

Monitorowanie aplikacji hybrydowych. Cordova i HockeyApp

Monitorowanie aplikacji hybrydowych jest bardzo ważnym etapem w produkcji każdego rozwiązania IT. Dlatego jego wybór może być kluczowym punktem każdego projektu.

Z własnego doświadczenia powiem im szybciej się zdecydujemy na dane rozwiązanie tym lepiej.

W trakcie produkcji aplikacji na którymś jej etapie stajemy przed wyborem metody monitorowania na urządzeniach. Dzisiaj chciałbym się skupić na  Apache Cordova i rozwiązaniu do monitorowania HockeyApp.

Nie będę się tutaj rozpisywał na temat samej Apache Cordova ponieważ zostało już wiele powiedziane i napisane. Skupmy się na HockeyApp co nam daje ta technologia i dlaczego ją wybrałem.

HockeyApp

Dlaczego akurat HockeyApp, a nie jakieś inne rozwiązanie do monitorowania aplikacji mobilnych lub pisanych w JavaScript.

Przyczyna była prosta jest to obecnie produkt Microsoft, mamy plugin dla Cordova, oraz API jest bardzo proste w użyciu. No może też kryterium była znajomość tego narzędzia :).

Instalacja

W celu dodania do naszej aplikacji HockeyApp SDK musimy zainstalować odpowiedni plugin. Robimy to komendą

cordova plugin add cordova-plugin-hockeyapp@latest

Kolejnym krokiem jest konfiguracja naszej aplikacji w panelu administratora i generacja App ID które jest wymagane przez SDK do komunikacji. W tym celu klikamy New App w panelu i podążamy według kroków.

automatyczne definiowanie aplikacji

Możemy cały proces wykonać również ręcznie. W tym celu klikamy „Create the app manually instead”.

ręczne definiowanie aplikacji

Po poprawnym skonfigurowaniu aplikacji mamy wygenerowany app id dla naszej aplikacji.

wygenerowania aplikacja

Możliwości

Jako, że skupiam się w tym artykule na monitorowaniu aplikacji przedstawię najważniejsze możliwe opcje. HockeyApp dla Cordova daje nam dostęp do:

  • Pobrania feedback od użytkownika
  • Pobrania feedback z dodatkowymi meta danymi od użytkownika
  • Monitorowania zdarzeń w aplikacji
  • Rozszerzone raporty z błędami

Jak tego wszystkiego użyć…?

API jest dostępne na event ondeviceready w globalnym obiekcie hockeyapp jest ono wystawiane przez szereg dostępnych metod. Które jest niezwykle proste w użyciu.

hockeyapp.addMetaData(null, null { someCustomProp: 23, anotherProp: "Value" });
hockeyapp.trackEvent(null, null, "EVENT_NAME");
hockeyapp.feedback();
hockeyapp.composeFeedback(null, null, true, appData);

W ramach podsumowania

HockeyApp daje nam szybki i łatwy dostęp do rozwiązania dającego nam możliwość monitorowania aplikacji w produkcji. Znacie jakieś inne narzędzia do monitorowania hybrydowych aplikacji mobilnych? Dajcie znać w komentarzach.

 

 

EF Core 2.0 w Xamarin Forms - Szybki start

EF Core 2.0 w Xamarin Forms – Szybki start

Programiści Xamarin często wykorzystują w swoich projektach lokalne bazy danych. Tutaj z pomocą przychodzą nam frameworki O/RM takie jak Entity Framework Core.

Entity Framework Core jest cross platformową wersją popularnego framework O/RM ze świata Microsoft. Za jego pomocą możemy w prosty sposób tworzyć warstwę dostępu do danych. Udostępnia on również wiele bardziej zaawansowanych funkcjonalności.

Niestety wersja 1.0 oferowała nam niewiele ale teraz od paru tygodni mamy nową jeszcze ciepłą wersję 2.0.

.NET Standard 2.0

Żeby zacząć swoją pracę z EF Core 2.0 musimy na początek stworzyć projekt .Net Standard 2.0 jest to wymagana zależność dla EF Core.

Nie będę się tutaj zagłębiał w niuanse związane z migracją do .NET Standard 2.0 ponieważ już zostało na ten temat dużo powiedziane np. tutaj Snack Pack 15: Upgrading to Xamarin.Forms to .NET Standard.

Szybki start

Żeby zacząć z EF Core należy na początek zainstalować pakiet NuGet Microsoft.EntityFrameworkCore.Sqlite 2.0.0.

Pakiet należy dodać do wszystkich naszych projektów.

Model

Nasza aplikacja będzie obsługiwała Sesję gry w której może być kilku graczy i właśnie takie informacje będziemy chcieli przechować w naszej bazie danych.

    public class Session
    {
		public int Id { get; set; }
		public DateTime Date { get; set; }
        public string TrackName { get; set; }
        public List<Player> Players { get; set; }
    }

    public class Player
    {        
        public int Id { get; set; }
        public int SessionID { get; set; }
		public string Name { get; set; }
        public string Time { get; set; }
    }

DbContext

Kolejnym naszym krokiem jest stworzenie DbContext. Jest to element centralny EF Core pełniący rolę repozytorium i obsługujący sesję z bazą danych.

    public class RankingsDbContext : DbContext
    {
        public DbSet<Session> Sessions { get; set; }
        public DbSet<Player> Players { get; set; }

        public RankingsDbContext()
        {
            Database.EnsureCreated();
        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            var dbPath = DependencyService.Get<IFileHelper>().GetLocalPath("rankingsDb.db3");
            optionsBuilder.UseSqlite($"Filename={dbPath}");
        }
    }

Co dalej

Mamy już stworzone nasze modele, oraz DbContext. Teraz należy wykonać jakieś zapytanie na bazie danych.

W tym celu robimy zapytanie i gotowe.

                context.Sessions.Add(newSession);
                context.Players.AddRange(newSession.Players);

Podsumowanie

Jak widzicie użycie EF Core w aplikacjach Xamarin.Forms stało się teraz proste i przyjemne. W następnych postach przyjrzymy się kolejnym nowością, oraz ich zastosowaniom w aplikacjach mobilnych.

Apache Cordova i moje odczucia

Apache Cordova i moje odczucia

Niniejszy post jest tylko moją opinią i w żaden sposób nie podziela opinii mojej firmy.
 
Tak się złożyło, że przez ostatnie 2 miesiące zajmowałem się tworzeniem aplikacji hybrydowej z wykorzystaniem Apache Cordova oraz jQuery Mobile.
 
Dzisiaj chciałbym się z wami podzielić moimi odczuciami na temat tego framework, oraz pracy z nim w realnym projekcie. A więc zaczynajmy…
 

Background

Na początek chciałbym wprowadzić pewien kontekst w jakim będę chciał ocenić wywyższy framework.
 
Moim zadaniem było stworzenie aplikacji mobilnej na potrzeby jednego eventu z możliwością wyświetlenia video na żywo. Aplikacja powinna również posiadać lokalną bazę danych żeby dane nie musiały być ściągane za każdym razem z serwera.
 
Wybór padł na użycie:

  • Apache Cordova
  • jQuery Mobile
  • HTML5 local storage (lub jak inaczej się to ładnie nazywa)
  • MJPEG

 
Pomysł prosty i powiedzmy sprawdzony w boju przez wiele firm bądź nie…
 

Apache Cordova

Apache Cordova jest frameworkiem open-source do tworzenia aplikacji mobilnych z użyciem HTML, CSS i JavaScript. Technicznie nie jest to nic innego jak kontener opakowujący WebView i uruchamiający stronę web w natywnej przeglądarce dla danej platformy.

Kontener ten stanowi pewnego rodzaju wrapper pomiędzy natywnym API danej platformy, a aplikacją napisaną w HTML. Daje to nam możliwość w miarę łatwego dostępu do API urządzania. W moim przypadku był to Android i iOS.
 
Dlaczego Apache Cordova? I czemu aplikacja hybrydowa?
 
Padło na stworzenie aplikacji hybrydowej z jednej przyczyny no może trzech. HTML, CSS i JavaScript, oraz łatwość znalezienia programistów znających te technologie.
 
Bardzo łatwo jest stworzyć prostą aplikację klasy Todo app niestety problemy zaczynają się pojawiać w sytuacji gdy chcemy zacząć robić coś więcej. Tutaj z pomocą czasami mogą przyjść nam pluginy.
 

Cordova Plugins

Dają one dostęp do dodatkowych funkcjonalność jak np. logowanie za pomocą sieci społecznościowych lub dostęp do natywnych powiadomień.
 
Koncepcja fajna niestety posiadająca wiele niedociągnięć.
 
Bardzo często pluginy są rozwijane przez pojedynczych programistów w ich wolnym czasie co w efekcie sprawia, że są one różnej jakości. Nie twierdzę, że jest to coś złego niestety zmusza do przeszukiwania StackOverflow lub GithHub Issues w poszukiwaniu rozwiązań.
 
Wiele pluginów wymaga do działania różnych „niebezpiecznych” uprawnień na różnych platformach np. dostęp do dysku.
 

jQuery Mobile

Kolejny komponent który może ułatwić pracę ponieważ sama Cordova niewiele potrafi.
 
Niestety nie ma róży bez kolców i jQM od wielu miesięcy nie jest chyba rozwijane . Najnowsza wersji 1.5 jest od paru ładnych miesięcy wersją alpha.
 
Szczęście w nieszczęściu nawet działa i nie sprawia za wiele problemów. No może za wyjątkiem ciągłej walki ze stylami CSS.
 
To był chyba najtrudniejszy etap projektu, czyli zmiana wyglądu aplikacji.
 

Podsumowania słów kilka

Jak widzicie moje odczucia raczej można powiedzieć są negatywne. Może to wynikać z mojej ogólnej niechęci do JavaScript :).
 
Są one jednak poparte pracą nad realnymi problemami w realnym projekcie. Dlatego na chwilę obecną raczej bym się nie zdecydował na użycie Cordova w następnym projekcie.
 
Pytanie pozostaje czy np.. Xamarin Forms byłby lepszy?
 
Wiadomo każdy framework ma swoje plusy i minusy jak również wszystko zależy od konkretnego przypadku.
 
W moim przypadku może lepszym byłoby użycie np.. Firebase niestety w założeniach mieliśmy również minimalizację usług third party :).

Rider nowe IDE od JetBrains – pierwsze wrażenia

A więc dzisiaj miałem swoją pierwszą styczność z IDE innym niż Visual Studio.

Rider nowe IDE od JetBrains

Rider – pierwsze wrażenia

Samo IDE wygląda trochę jak połączenie Visual Studio i Eclipse :), czyli na plus można się w nim odnaleźć.

Niestety w wielu miejscach jest nieczytelne do tej pory nie udało mi się znaleźć informacji czy biblioteka, którą stworzyłem jest typu portable czy też nie?

Problematyczne jest również stworzenie biblioteki PCL lub zmiany Target Framework dla .Net Standard. Out-of-the-box ustawia się .netstandard1.4

Chociaż również mnie zaskoczyło pozytywnie wsparciem out-of-box dla c# 7.0.
Kolejne zaskoczenie Power Save Mode, czyli wyłączenie wszystkich rzeczy które chodzą w tyle dla oszczędzania baterii.

Jeżeli chodzi o Xamarin Forms to można stworzyć projekt\solution ręcznie niestety nie ma gotowego template.

Rodzina

Rodzina

Rodzina jest czymś bardzo ważnym w życiu każdego człowieka, niestety w świecie ciągłego biegu często o niej zapominamy.

Żyjemy w świecie w którym każdy pędzie

Każdy jest pochłonięty tylko pracą, ale zapomina o jednej najważniejszej rzeczy o rodzinie.

Jeżeli jest to „zdrowa” to możemy liczyć na wsparcie, dobre słowo albo przysłowiowego kopniaka w tyłek jak zaczyna nam brakować motywacji do działania.

Rodzina wesprze w trudnych chwilach

Żaden przyjaciel, znajomy nie zapewni nam tego co może nam dać rodzina dlatego dbajmy o nią. Spędzajmy jak najwięcej czasu razem i niech wam nikt nie wmawia, że trzeba zostać dłużej czasu w pracy itp.

Starajmy się pracować tylko tyle ile jest to konieczne żeby włożyć coś do garnka. Resztę czasu poświęćmy na czas z rodziną, a dan nam ona duża dawkę satysfakcji i szczęścia.

A to jest ważniejsze niż wszystkie pieniądze świata.

Dependency Service do czego jest nam potrzebny?

Dependency Service do czego jest nam potrzebny?

Chciałbym dzisiaj wam przybliżyć czym jest Dependency Service i do czego jest nam potrzebny.

Czym jest Dependency Service

Xamarin Forms jest technologią multi-platformową w której większość kodu aplikacji definiujemy w bibliotece PCL lub Shared. Niestety wymusza to na nas pewne ograniczenia. Największym jest brak możliwość dostępu do natywnych funkcjonalność danej platformy.

Mam tutaj na myśli usługi takie jak

  • Dostęp do plików
  • Poczta
  • Dostęp do hardware np. żyroskop
  • Notyfikacje
  • i wiele wiele innych

Każda z takich usług występuje na każdej platformie czy to będzie iOS czy Android, a może Windows. Niestety różnice na każdej z nich pociągają również różnice w sposobie implementacji i różnice w API. Stąd potrzebujemy czegoś co pozwoli nam używać różnych implementacji specyficznych dla każdej z platform i zarazem pozwoli nam wywołać ten kod z naszego Core aplikacji.

Dependency Service diagram

Z pomocą przychodzi nam Dependency Service.
Jak widzicie na załączonym obrazku nasz serwis chce uzyskać dostęp do informacji o baterii. Definiujemy interfejs tworzymy jego implementację na każdej z platform i wywołujemy poprzez Dependency Service. Wygląda prosto i takie jest też w rzeczywistości.

Przejdźmy dalej…

Dependency Service – Service Locator?

Sam w sobie Dependency Service nie jest niczym nowym. Pod spodem definiuje on wzorzec Service Locator (przynajmniej tak mi się wydaje :)).

Możemy dojść do takiego wniosku analizując kod źródłowy (tak od jakiegoś czasu mamy dostęp do kodu źródłowego Xamarin Forms na GitHub).

Ma on zdefiniowane podstawowe metody

  • Get
  • Register

Poniżej przykład metody Register

		public static void Register<T>() where T : class
		{
			Type type = typeof(T);
			if (!DependencyTypes.Contains(type))
				DependencyTypes.Add(type);
		}

		public static void Register<T, TImpl>() where T : class where TImpl : class, T
		{
			Type targetType = typeof(T);
			Type implementorType = typeof(TImpl);
			if (!DependencyTypes.Contains(targetType))
				DependencyTypes.Add(targetType);

			DependencyImplementations[targetType] = new DependencyData { ImplementorType = implementorType };
		}

Ciekawsze rzeczy dzieją się na etapie tworzenia nowej instancji

		static void Initialize()
		{
			if (s_initialized)
			{
				return;
			}

			Assembly[] assemblies = Device.GetAssemblies();
			if (Internals.Registrar.ExtraAssemblies != null)
			{
				assemblies = assemblies.Union(Internals.Registrar.ExtraAssemblies).ToArray();
			}

			Initialize(assemblies);
		}

		internal static void Initialize(Assembly[] assemblies)
		{
			if (s_initialized)
			{
				return;
			}

			Type targetAttrType = typeof(DependencyAttribute);

			// Don't use LINQ for performance reasons
			// Naive implementation can easily take over a second to run
			foreach (Assembly assembly in assemblies)
			{
				Attribute[] attributes = assembly.GetCustomAttributes(targetAttrType).ToArray();
				if (attributes.Length == 0)
					continue;

				foreach (DependencyAttribute attribute in attributes)
				{
					if (!DependencyTypes.Contains(attribute.Implementor))
					{
						DependencyTypes.Add(attribute.Implementor);
					}
				}
			}

			s_initialized = true;
		}

Nie będę tutaj wchodził już w szczegóły ponieważ wyjdą one później.

Tworzymy własną implementację

Chciałbym wam pokazać jak zaimplementować „użycie” Dependency Service. Zrobimy to na przykładzie z baterią. Cały kod źródłowy jest do pobrania z GitHub

Interfejs na początek

Trzeba stworzyć nowy interfejs w naszym przykładzie jest to IBatteryService.

    public interface IBatteryService
    {
        int RemainingChargePercent { get; }

        Models.BatteryStatus Status { get; }

        Models.PowerSource PowerSource { get; }
    }

Implementacja

Kolejny krok to stworzenie implementacji na każdej z platform. W tym przykładzie użyjemy tylko Android.

    public class BatteryService : BatteryStatus.Infrastructure.IBatteryService
    {
        public int RemainingChargePercent
        {
            get
            {
                try
                {
                    using (var filter = new IntentFilter(Intent.ActionBatteryChanged))
                    {
                        using (var battery = Application.Context.RegisterReceiver(null, filter))
                        {
                            var level = battery.GetIntExtra(BatteryManager.ExtraLevel, -1);
                            var scale = battery.GetIntExtra(BatteryManager.ExtraScale, -1);

                            return (int)Math.Floor(level * 100D / scale);
                        }
                    }
                }
                catch
                {
                    System.Diagnostics.Debug.WriteLine("Ensure you have android.permission.BATTERY_STATS");
                    throw;
                }
            }
        }
...

Jest to tylko fragment implementacji dający nam tylko pogląd jak to powinno wyglądać.

Rejestracja

Gdy mamy już gotową implementację musimy ją zarejestrować żeby Dependency Service mógł go później użyć. Robimy to w prosty sposób poprzez nadanie atrybutu na namespace.

[assembly:Xamarin.Forms.Dependency(typeof(BatteryStatus.Droid.Infrastructure.BatteryService))]
namespace BatteryStatus.Droid.Infrastructure

Wywołanie\Użycie

W naszym przykładzie użyjemy naszego serwisu w ViewModel. Robimy to poprzez użycie metody Get z Dependency Service.

        public BatteryStatusViewModel()
        {
            var batteryService = DependencyService.Get<IBatteryService>();

            if (batteryService == null)
                return;

            this.BatteryStatus = batteryService.Status.ToString();
            this.PowerSource = batteryService.PowerSource.ToString();
            this.RemainingCharge = batteryService.RemainingChargePercent;
        }

Podsumowanie

Uff. Dobrnęliśmy do końca całości.
Użycie Dependency Service daje nam bardzo potężne możliwości, oraz dostęp do wielu natywnych funkcjonalności platform.

Jak konfigurować emulatory Android dla początkujących

works on my machine

Konfiguracja emulatora Android może być czasami problematyczna. Dlatego chciałbym przedstawić jak to zrobić poprawnie tak żeby wszystko działało.

Jest to artykuł skierowany głównie do początkujących developerów Xamarin i nie tylko.

Emulatory Android

Jeżeli chodzi o emulatory android mamy kilka możliwych opcji do wyboru

Dzisiaj chciałbym się skupić na emulatorach dostarczanych wraz z Android SDK, czyli Google APIs Intel x86.

HAXM

HAXM, czyli Intel Hardware Accelerated Execution Manager jest to technologia firmy Intel „usprawniająca działanie emulatorów Android na komputerach wyposażony w procesory Intel.

Intel® Hardware Accelerated Execution Manager (Intel® HAXM) is a hardware-assisted virtualization engine (hypervisor) that uses Intel® Virtualization Technology (Intel® VT) to speed up Android* app emulation on a host machine. In combination with Android x86 emulator images provided by Intel and the official Android SDK Manager, Intel HAXM allows for faster Android emulation on Intel VT enabled systems.

Intel® Hardware Accelerated Execution Manager (Intel® HAXM)

Dzięki wykorzystaniu technologi Intel VT emulatory dostarczane przez Google we współpracy działają z pełną szybkością procesora dostępnego w komputerze.

Przygotowanie środowiska

W celu pobrania najnowszych emulatorów musimy otworzyć Android SDK Manager, możemy to zrobić z poziomu Visual Studio VS Android SDK manager
Wybieramy emulator, który nas interesuje i pobieramy wraz z odpowiednim SDK. Ważne żebyśmy wybrali emulator w wersji x86 Atom
Google APIs System Image

No dobrze ale możecie zapytać co z tym całym HAXM?
Z moich obserwacji wynika, że najlepiej jest zainstalować HAXM dostarczany wraz z Visual Studio 2017.
Intel HAXM

Obserwacje zostały przeprowadzone na komputerze wyposażonym w procesor Intel i5-6300U.

Konfiguracja emulatora

W celu stworzenia nowego emulatora otwieramy Android Virtual Device (AVD) Manager, możemy to zrobić z poziomu Visual Studio VS AVD manager
AVD Manager

Następnie klikamy Create i wybieramy Device (głównie godzi tu o wymiary UI i ilość pamięci), oraz Target API level
new emulator

Ważne żebyśmy wybrali opcję Use Host GPU emulator działa wtedy jeszcze szybciej, przynajmniej na mojej maszynie.

Xamarin Live Player, podgląd UI na żywo - obecny stan

Xamarin Live Player, podgląd UI na żywo – obecny stan

Jakiś czas temu Xamarin opublikował narzędzie o nazwie Xamarin Live Player, szczegóły można znaleźć pod URL www.xamarin.com/live. Dzisiaj pokażę wam jak wygląda w praktyce użycie tego narzędzia i jakie są jego zalety, wady, oraz ograniczenia na chwilę obecną.

Xamarin Live Player – Setup

Na chwilę obecną Xamarin Live Player jest dostępny tylko w wersji Preview Visual Studio 2017, a więc zaczynamy instalację.

Na początek trzeba pobrać Visual Studio 2017 Preview 15.3 z tego linka www.visualstudio.com/vs/preview/. W ten sposób zainstalujemy instalator Visual Studio. Ważna uwaga wersja Preview może działać obok stabilnej wersji Visual Studio 2017 w czasie instalacji wystarczy stworzyć „Installation nickname”. Installation nickname
Wybieramy Workload Mobile Development with .Net i rozpoczynamy instalację.

Kolejny krok to instalacja Xamarin Updater. Jest to bardzo przydatne narzędzie ze względu na zmianę sposobu aktualizacji Xamarin wraz z wypuszczeniem Visual Studio 2017. Samo narzędzie możemy pobrać z marketplace.visualstudio.com.

Pierwsza aplikacja – czy wszystko nam działa?

Otwieramy Visual Studio Preview i tworzymy nowy projekt nazwijmy go „TodoLivePlayer”

LivePlayerDemo

Kolejny krok to instalacja na urządzeniu z iOS lub Android aplikacji Xamarin Live, którą można pobrać ze sklepu

Teraz możemy sparować urządzenie z Visual Studio w tym celu otwieramy menu Tools -> Xamarin Live Player -> Manage Devices

Manage devices
pair device

Na urządzeniu otwieramy aplikację i jeżeli jest ono wyposażone w aparat możemy przeczytać wygenerowany kod QR w innym wypadku trzeba przepisać kod wygenerowany na urządzeniu do Visual Studio.

Xamarin Live QR code

Xamarin Live

Cały proces jest mało problematyczny i przebiega bardzo płynnie.

Co obecnie działa?

Głównie testowałem Live Player na iPhone i na chwilę obecną jest jedno w mojej opinii niewielkie ograniczenie nie działa to z PCL. Jak tylko sprawdzę .Net Standard to pojawi się aktualizacja.

W ramach podsumowania

Live Player jest kolejnym ciekawym narzędziem ułatwiającym pracę z Xamarin. Bardzo ułatwia i przyśpiesza pracę na aplikacjami i jego powstanie\rozwój jest kolejnym przykładem, że Xamarin jest ważną i przyszłościową platformą.

WażneNależy również pamiętać, że urządzenia na których chcemy robić testy musi znajdować się w naszej sieci Wi-Fi.

Szkice, rysunki, prototyp, czyli jak to wszystko się zaczyna

Szkice, rysunki, prototyp, czyli jak to wszystko się zaczyna

Każdy projekt informatyczny, lepiej brzmi IT ma gdzieś swój początek. Przeważnie jest to głowa projektanta, analityka, itd.

No dobrze ale jak to wszystko dokładnie poprowadzić z punktu A do Z? I jak to wygląda w wypadku 10 Ideas.
Na początek mockupy ekranów. Zaznaczam, że nie jestem profesjonalnym grafikiem i staram się jak mogę :).

Mockup

Tak wyglądają pierwsze szkice UI aplikacji. Nie wygląda to zbyt obiecująco ale na początek chciałbym stworzyć działający prototyp.

Stąd też moja prośba będę poszukiwał chętnych do testowania i podpowiadania jakie funkcjonalności jeszcze mogą się przydać. Zapraszam do kontaktu.