Schnelle Iteration mit Django & Heroku

German (Deutsch) translation by Katharina Grigorovich-Nevolina (you can also view the original English article)

Schnelle Iteration mit Django & HerokuDie Gründung eines Online-Geschäfts kann sich als äußerst kompliziert erweisen. Obwohl es auf dem Papier einfacher ist, ein Online-Geschäft zu gründen, als ein stationäres Geschäft, kann sich ein Unternehmer in einer Vielzahl von Optionen verlieren. Einige der häufigsten Fallstricke, in die ein Online-Unternehmer steckt, sind:

Zu früh zu viel bauen: Verlieren Sie Zeit und verbrennen Sie Geld, um ein kompliziertes Produkt aufzubauen. Werden Sie demotiviert, verlieren Sie den Glauben an das Produkt und verlassen Sie das Projekt.
Zu viel an die Idee glauben: An der ursprünglichen Idee festhalten und sie nicht wiederholen, auch wenn die Kunden nicht auftauchen, nicht zahlen oder nicht zufrieden sind.
Nicht anfangen: Wenn jemand anfängt, ein Webprojekt aufzubauen, kann er/sie von den scheinbar unendlichen Entscheidungen und Entscheidungen, die getroffen werden müssen, überwältigt werden. Was für ein Hosting? Welche Plattform? Welches WordPress-Thema? Wie baue ich eine Startseite mit hohem Conversion-Wert? Welche Programmiersprache und welche Datenbank? Sollten Sie ein Webframework verwenden? Vanilla JavaScript oder jQuery für das Frontend? Vielleicht ein komplexeres Frontend-Framework, weil das Projekt eines benötigt, sobald es reif genug ist?
Fehler beim Starten: Beim Erstellen eines Webprojekts können Sie, obwohl Sie sich für Ihren Technologie-Stack entschieden haben, von der Bewertung, das Sie erhalten, überwältigt werden. Es ist unabsichtlich ein Fehler, zu viel Feedback zu hören. Es kann die Bewertung von Leuten sein, die Ihr Produkt sowieso nicht verwenden würden. Menschen neigen dazu, eine Meinung über alles zu haben, auch wenn sie sich in diesem Bereich nicht vollständig auskennen.

Angesichts der Vielzahl von Möglichkeiten, die man auf der Straße versagen kann, ist es wichtig:

Bauen Sie so wenig und so schnell wie möglich auf und zeigen Sie es den Menschen, die Sie als potenzielle Kunden betrachten: Minimieren Sie Kosten und Aufwand.
Setzen Sie es so schnell wie möglich online: Holen Sie sich Bewertung von Personen zum Produkt, nicht zu Ihrer abstrakten Idee.
Nehmen Sie Änderungen schnell vor: Wenn Sie lernen, was der Kunde will, ist es wichtig, dass Sie agil sind und Ihre ersten zahlenden Kunden gut bedienen.

Hier setzt Prototyping an. Ein Unternehmer sollte schlank arbeiten und keine Zeit und Ressourcen verschwenden. Am Anfang so wenig wie möglich zu bauen, kann sich als Tugend erweisen.

Es gibt viele Denkrichtungen darüber, was ein Prototyp ist und wie er erstellt werden sollte. Einige sagen, dass es nur eine Startseite sein sollte, andere, dass es eine abgespeckte Version des Endprodukts sein sollte. Ich bin eher ein Fan der Sekunde. Wenn Sie nur eine Zielseite verwenden, kann sich das als unangenehm empfinden. Außerdem erhalten Sie keine Rückmeldung, wie Sie das Problem lösen, sondern nur, wenn das Problem es wert ist, es zu lösen.

Hier ist der Toolbelt eines Smart-Prototyping-Online-Unternehmers:

Front-End-Frameworks: Bootstrap, Foundation, jQuery, Vue usw. Durch die Verwendung eines Front-End-Frameworks können Ihre Apps auf verschiedenen Bildschirmgrößen und verschiedenen Browsern mit einem anständigen Design arbeiten.
Backend-Frameworks: Django, Ruby on Rails, Laravel. Die Verwendung von Back-End-Frameworks erleichtert Ihnen den Umgang mit HTML-Vorlagen, HTTP-Formularen, Datenbankzugriff, URL-Schemata usw.
Plattform-as-a-Service: Heroku, Google App Engine, AWS Elastic Beanstalk. Die Auswahl eines PaaS-Systems kann Sie von der Verwaltung von Servern, der Protokollaggregation, der Überwachung der Betriebszeit, der Bereitstellungsinfrastruktur und vielem mehr befreien.

In diesem Tutorial erstellen wir eine einfache Anwendung im Sinne von Rapid Prototyping. Wir werden Django, Bootstrap CSS und Heroku verwenden. Der Fokus liegt auf dem Backend-Teil und nicht auf dem Frontend.

Wir werden die Heroku-Plattform nutzen, um etwas früh online zu stellen und neue Funktionen schnell bereitzustellen. Wir werden Django verwenden, um komplexe Datenbankmodelle und Funktionen zu erstellen. Bootstrap CSS gibt uns einen sinnvollen Standardstil für unsere Seiten. Genug reden, lassen wir uns gehen.

Was wir bauen

Stellen Sie sicher, dass Sie sich für diesen einen Platz nehmen. Die Idee wird Ihre Socken abschrecken. Hier ist die Neigung: Hassen Sie nicht einfach, wie Sie diese Rabattcodes bekommen, aber Sie vergessen sie zu verwenden und sie verfallen?

Wäre es nicht cool, die Codes an einem Ort zu speichern, an dem Sie sie suchen können und auch benachrichtigt werden, wenn sie ablaufen? Ich weiß, tolle Idee, richtig? Nun, legen Sie Ihre Kreditkarte aus, Sie werden nicht in diese investieren. Sie werden es bauen.

Anfangen

In diesem Tutorial werde ich Python 3 verwenden. Wenn Sie Python 2.7 verwenden, sollten die Änderungen relativ einfach sein. Ich gehe auch davon aus, dass Sie mit setuptools, Python virtualenvs und Git vertraut sind. Eine weitere Sache, bevor Sie fortfahren: Stellen Sie sicher, dass Sie über einen GitHub- und einen Heroku-Account verfügen. Um Heroku verwenden zu können, müssen Sie auch die Heroku-CLI installieren.

Beginnen wir mit der Erstellung einer Virtualenv:

$ mkvirtualenv coupy

Wie Sie wahrscheinlich herausgefunden haben, lautet unser Anwendungsname Coupy. Wechseln wir zum neuen virtualenv $ workon coupy und installieren Sie Django:

$ pip install Django

Gehen Sie in Ihr GitHub-Konto und erstellen Sie ein neues Projekt. Als nächstes lassen wir uns das Projekt klonen:

$ git clone https://github.com/<GITHUB_USERNAME>/<GITHUB_PROJECT_NAME>.git
$ cd <GITHUB_PROJECT_NAME>

Der nächste logische Schritt ist das Erstellen eines Django-Projekts.Um ein Django-Projekt in Heroku zu implementieren, müssen wir einige Richtlinien befolgen.Glücklicherweise können wir dafür eine Projektvorlage verwenden. So geht's:

$ django-admin.py startproject --template=https://github.com/heroku/heroku-django-template/archive/master.zip --name=Procfile coupy

Möglicherweise müssen Sie sich in einigen Ordnern bewegen. Stellen Sie sicher, dass Ihr Repository-Stammordner folgendermaßen aussieht:

.
├── Procfile
├── README.md
├── coupy
│   ├── __init__.py
│   ├── settings.py
│   ├── static
│   │   └── humans.txt
│   ├── urls.py
│   └── wsgi.py
├── manage.py
├── requirements.txt
└── runtime.txt

Lassen Sie uns nun die Anforderungen der Vorlage installieren:

$ pip install -r requirements.txt

Wir möchten nun die neu erstellten Dateien auf GitHub übertragen:

$ git add .
$ git commit -m"Init Django project"
$ git push origin master

Sehen wir, ob das, was wir bisher gemacht haben, funktioniert:

$ python manage.py runserver

Öffnen Sie nun ein Browserfenster und gehen Sie zu http://localhost:8000. Wenn alles gut ist, sollten Sie die klassische Django-Begrüßungsseite sehen. Um sicherzustellen, dass aus Sicht von Heroku alles gut ist, können wir die Anwendung auch so ausführen:

$ heroku local web

Um zu beweisen, wie schnell wir online gehen können, machen wir unsere erste Bereitstellung bei Heroku:

$ heroku login
$ heroku create

Wir haben jetzt eine Heroku-Anwendung erstellt, aber wir haben keinen Code an Heroku gesendet. Beachten Sie, dass Heroku eine benutzerfreundliche App-ID erstellt hat. Hier ist die Ausgabe, die Sie erhalten sollten:

Creating app... done, ⬢ <HEROKU_APP_ID>
https://<HEROKU_APP_ID>.herokuapp.com/ | https://git.heroku.com/<HEROKU_APP_ID>.git

Jetzt müssen wir unser Repo mit der neu erstellten Heroku-App verknüpfen:

$ heroku git:remote -a <HEROKU_APP_ID>
$ git push heroku master
$ heroku open

Toll, Sie haben gerade eine App für Heroku bereitgestellt. Es macht nicht viel, aber Sie stellen etwas in Rekordzeit online. Gut gemacht.

Einrichten der Datenbank

Sie werden wahrscheinlich niemals eine nicht triviale Web-App ohne Datenbank erstellen. Die Datenbank ist der Datenspeicher der Web-App. Hier behält die Web-App ihren Status (zumindest den Großteil davon). Hier führen wir die Benutzerkonten und die Anmeldedaten und vieles mehr. Heroku bietet einen verwalteten PostgreSQL-Dienst.

Das werden wir verwenden. Stellen Sie sicher, dass Sie Postgres auf Ihrem Computer installiert haben, und erstellen Sie eine Datenbankinstanz, die in unserer Anwendung verwendet werden soll. Heroku benötigt eine Umgebungsvariable, um eine Verbindung zum Datenbankdienst herzustellen. Die Variable, die wir setzen müssen, ist DATABASE_URL:

$ export DATABASE_URL="postgres://<USERNAME>:<PASSWORD>@localhost:5432/<DATABASE_NAME>"

Lassen Sie uns nun Django sagen, dass er die Migrationen anwenden und die erforderlichen Tabellen erstellen soll:

$ ./manage.py migrate

Erstellen Sie einen Superuser und melden Sie sich an der Administrationsoberfläche unter http://localhost:8000/admin an.

$ ./manage.py createsuperuser
$ ./manage.py runserver

Wir können sehen, dass die Tabellen tatsächlich erstellt wurden. Heroku hat Ihrer App bereits standardmäßig eine Datenbankinstanz zugeordnet. Sie können sicherstellen, dass dies der Fall ist, indem Sie Heroku HEROKU_APP_ID > Settings > Config Variablesin Ihrer Heroku Online-Konsole einchecken. Sie sollten hier sehen, dass DATABASE_URL auf eine von Heroku generierte Datenbankadresse gesetzt ist.

Wir müssen jetzt die Migrationen ausführen und die Super User-Befehle online erstellen. Lassen Sie uns sehen, ob alles wie erwartet funktioniert:

$ heroku run python manage.py migrate
$ heroku run python manage.py createsuperuser

Wenn alles gutgegangen ist und wir https://<HEROKU_APP_ID>. herokuapp.com/admin/ besuchen, sollten wir uns mit den gerade angegebenen Anmeldeinformationen anmelden können.

Benutzerauthentifizierung

In diesem Abschnitt initialisieren wir eine Django-App und verwenden vordefinierte Django-Komponenten, um die Benutzerauthentifizierung-Funktion in unserer App zu erstellen.

$ ./manage.py startapp main

In der neuen App erstellen wir eine urls.py-Datei:

from django.conf.urls import url
from django.contrib.auth import views as auth_views
from django.views.generic.base import RedirectView


urlpatterns = [
    url('^$', RedirectView.as_view(url='login'), name='index'),
    url(r'^login$', auth_views.LoginView.as_view(), name='login'),
    url(r'^logout$', auth_views.LogoutView.as_view(), name='logout'),
]

Hier verwenden wir drei generische Django-Ansichten:

RedirectView: Da die Basis-URL der Anwendung nichts tut, wird auf die Anmeldeseite umgeleitet.
LoginView: Vordefinierte Ansicht von Django, die das Login-Formular erstellt und die Benutzerauthentifizierung-Routine implementiert.
LogoutView: Vordefinierte Ansicht von Django, die einen Benutzer abmeldet und zu einer bestimmten Seite umleitet.

Fügen Sie die main-Anwendung der Liste INSTALLED_APPS hinzu:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    # Disable Django's own staticfiles handling in favour of WhiteNoise, for
    # greater consistency between gunicorn and `./manage.py runserver`. See:
    # http://whitenoise.evans.io/en/stable/django.html#using-whitenoise-in-development
    'whitenoise.runserver_nostatic',
    'django.contrib.staticfiles',

    'main',
]

Verbinden Sie die main.urls mit dem Stamm-URL-Schema:

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^', include('main.urls')),
    url(r'^admin/', admin.site.urls),
]

Um die Formulare richtig darzustellen, mit Stilen und Klassen und allem, müssen wir django-widget-tweaks installieren

$ pip install django-widget-tweaks
$ pip freeze > requirements.txt

Fügen Sie django-widget-tweaks zu INSTALLED_APPS hinzu:

INSTALLED_APPS = [
    # ...
    'main',
    'widget_tweaks',
]

Wir fügen jetzt diese beiden Konfigurationen zu settings.py hinzu:

LOGIN_REDIRECT_URL: Teilt Django mit, wohin ein Benutzer nach einer erfolgreichen Authentifizierung umgeleitet werden soll.
LOGOUT_REDIRECT_URL: Gibt Django an, wohin der Benutzer umgeleitet werden soll, nachdem er sich abgemeldet hat.

# settings.py

LOGIN_REDIRECT_URL = 'dashboard'
LOGOUT_REDIRECT_URL = 'login'

Lassen Sie uns eine einfache Master-Vorlage base.html und eine dashboard.html-Vorlage schreiben, die sie erweitert. Wir kommen später zurück zum Dashboard.

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" />

    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <div class="container">
    {% block content %}{% endblock %}
    </div><!-- /container-->
</body>
</html>

{% extends 'base.html' %}

{% block title %}Dashboard{% endblock %}

{% block content %}
<h1>Dashboard</h1>
{% endblock %}

Schreiben Sie die Ansicht, die dashboard.html-Vorlage darstellt:

from django.shortcuts import render
from django.core.urlresolvers import reverse_lazy


@login_required(login_url=reverse_lazy('login'))
def dashboard(request):
    return render(request, 'dashboard.html')

Wir sind fertig. Gehen Sie zu http://localhost:8000/login/ und testen Sie, ob die Authentifizierung funktioniert. Als nächstes speichern Sie Ihren Fortschritt:

$ git add .
$ git commit -m"Login/Logout/Dashboard views"

Erstellen Sie das Coupon-Modell

Jetzt haben wir den wichtigsten Teil unserer Anwendung, das Coupon-Modell, entworfen. Wir werden django-model-utils installieren, um unseren Modellen zusätzliche Eigenschaften zu verleihen.

$ pip install django-model-utils
$ pip freeze > requirements.txt

Schreiben Sie das Coupon-Modell:

from model_utils.models import TimeStampedModel, TimeFramedModel
from django.db import models
from django.contrib.auth.models import User


class Coupon(TimeStampedModel, TimeFramedModel):
    owner = models.ForeignKey(User)
    discount_code = models.CharField("Discount Code", max_length=100)
    website = models.URLField("Website")
    description = models.TextField("Coupon Description")

Die von uns erweiterten django-model-utils-Modelle ermöglichen uns:

TimeStampedModel hilft uns zu verfolgen, wann das Modell über das created Feld in die Datenbank eingefügt wurde.
TimeFramedModel fügt dem Modell die start- und end-Felder hinzu. Wir verwenden diese Felder, um die Verfügbarkeit des Gutscheins zu verfolgen.

Haken Sie das Modell an den Admin:

from django.contrib import admin
from .models import Coupon


@admin.register(Coupon)
class CouponAdmin(admin.ModelAdmin):
    pass

Migrationen erstellen und anwenden:

$ ./manage.py makemigrations
$ ./manage.py migrate

Fortschritt speichern:

$ git add .
$ git commit -m"Create Coupon model"

ModelForm für die Coupon-Erstellung

Eine der coolsten Funktionen von Django ist die Möglichkeit, Formulare aus Modellklassen zu erstellen. Wir werden ein solches Formular erstellen, mit dem Benutzer Gutscheine erstellen können. Erstellen Sie eine Datei forms.py in der main-Anwendung:

from django.forms import ModelForm
from .models import Coupon


class CouponForm(ModelForm):
    class Meta:
        model = Coupon
        exclude = ('owner', ) # We're setting this field ourselves

Fügen Sie dieses Formular dem Dashboard hinzu. Wir müssen sowohl die Ansicht als auch die Vorlage ändern:

# views.py

from django.shortcuts import render, redirect
from django.core.urlresolvers import reverse_lazy
from .forms import CouponForm


@login_required(login_url=reverse_lazy('login'))
def dashboard(request):
    if request.method == 'POST':
        form = CouponForm(request.POST)
        if form.is_valid():
            coupon = form.save(commit=False)
            coupon.owner = request.user
            coupon.save()
            return redirect('dashboard')
    else:
        form = CouponForm()

    return render(request, 'dashboard.html', context={'create_form': form})

{% extends 'base.html' %}

{% load widget_tweaks %}

{% block title %}Dashboard{% endblock %}

{% block content %}
<h1>Dashboard</h1>

<form method="post">
    {% csrf_token %}
    <div class="form-group">
        <label for="discount_code">Discount Code</label>
        {% render_field create_form.discount_code class="form-control" placeholder="Discount Code" %}
    </div>

    <div class="form-group">
        <label for="website">Website</label>
        {% render_field create_form.website class="form-control" placeholder="Website" %}
    </div>

    <div class="form-group">
        <label for="description">Description</label>
        {% render_field create_form.description class="form-control" placeholder="Description" %}
    </div>

    <div class="form-group">
        <label for="start">Available From</label>
        {% render_field create_form.start class="form-control" placeholder="Available From (MM/DD/YYYY)" %}
    </div>

    <div class="form-group">
        <label for="end">Expires on</label>
        {% render_field create_form.end class="form-control" placeholder="Expires On (MM/DD/YYYY)" %}
    </div>

    <button type="submit" class="btn btn-primary">Save</button>
</form>


{% endblock %}

Wir haben jetzt eine Möglichkeit, Gutscheine über das Dashboard zu erstellen. Probier es aus. Wir haben keine Möglichkeit, die Gutscheine im Dashboard zu sehen, aber im Admin-Panel. Speichern wir den Fortschritt:

$ git add .
$ git commit -m"Coupon creation form in dashboard"

Bald auslaufende Coupons

Eine weitere Sache, die wir im Dashboard anzeigen möchten: Coupons, die bald ablaufen, zum Beispiel die, die diese Woche ablaufen.

Fügen Sie django.contrib.humanize zu INSTALLED_APPS hinzu, um Datumsangaben in den Vorlagen auf benutzerfreundliche Weise anzuzeigen.

Lassen Sie uns die Ansicht so verbessern, dass die bald auslaufenden Coupons abgerufen und an den Vorlagenkontext übergeben werden:

from datetime import timedelta

from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect
from django.core.urlresolvers import reverse_lazy
from django.utils import timezone

from .forms import CouponForm
from .models import Coupon


@login_required(login_url=reverse_lazy('login'))
def dashboard(request):
    expiring_coupons = Coupon.objects.filter(
        end__gte=timezone.now(),
        end__lte=timezone.now() + timedelta(days=7))

    if request.method == 'POST':
        form = CouponForm(request.POST)
        if form.is_valid():
            coupon = form.save(commit=False)
            coupon.owner = request.user
            coupon.save()
            return redirect('dashboard')
    else:
        form = CouponForm()

    return render(request, 'dashboard.html', context={
        'create_form': form,
        'expiring_coupons': expiring_coupons})

Lassen Sie uns die Vorlage so aktualisieren, dass die auslaufenden Coupons tabellarisch angezeigt werden. Das Erstellungsformular und die Tabelle werden mit Hilfe des Bootstrap-Rastersystems in zwei separate Spalten eingefügt:

{% extends 'base.html' %}

{% load widget_tweaks %}
{% load humanize %}

{% block title %}Dashboard{% endblock %}

{% block content %}
<h1>Dashboard</h1>
<div class="row">
    <div class="col-md-6">
        [The form code]
    </div>
    <div class="col-md-6">
        {% if expiring_coupons %}
            <table class="table">
                <thead>
                    <tr>
                        <th>Discount Code</th>
                        <th>Website</th>
                        <th>Expire Date</th>
                    </tr>
                </thead>
            {% for coupon in expiring_coupons %}
                <tr>
                    <td>{{coupon.discount_code}}</td>
                    <td>{{coupon.website}}</td>
                    <td>{{coupon.end|naturalday }}</td>
                </tr>
            {% endfor %}
            </table>
        {% else %}
            <div class="alert alert-success" role="alert">No coupons expiring soon</div>
        {% endif %}

        {% endblock %}
    </div>
</div>

Sieht gut aus. Speichern Sie Ihren Fortschritt:

$ git add .
$ git commit -m"Implementing the expiring coupon list"

Katalogansicht

Lernen Sie jetzt einige weitere Django-Verknüpfungen, um eine Ansicht zu erstellen, in der die Liste der verfügbaren Coupons angezeigt wird. Wir reden über generische Ansichten. So erstellen Sie schnell eine ListView:

# views.py

# ...
from django.views.generic.list import ListView
from django.db.models import Q


class CouponListView(ListView):
    model = Coupon

    def get_queryset(self):
        return Coupon.objects.filter(Q(end__gte=timezone.now()) | Q(end__isnull=True)).order_by('-end')

Binden Sie nun die Ansicht in Ihr URL-Schema:

# main/urls.py

from django.conf.urls import url
from django.contrib.auth import views as auth_views
from django.views.generic.base import RedirectView
from .views import dashboard, CouponListView


urlpatterns = [
    url('^$', RedirectView.as_view(url='login'), name='index'),
    url(r'^login/$', auth_views.LoginView.as_view(), name='login'),
    url(r'^logout/$', auth_views.LogoutView.as_view(), name='logout'),
    url(r'^dashboard/$', dashboard, name='dashboard'),
    url(r'^catalogue/$', CouponListView.as_view(template_name='catalogue.html'), name='catalogue'),

]

Erstellen Sie die Vorlage catalogue.html:

{% extends 'base.html' %}

{% load humanize %}

{% block title %}Catalogue{% endblock %}

{% block content %}
<h1>Catalogue</h1>
<div class="row">

    <div class="col-md-12">
        {% if object_list %}
            <table class="table">
                <thead>
                    <tr>
                        <th>Discount Code</th>
                        <th>Website</th>
                        <th>Expire Date</th>
                    </tr>
                </thead>
            {% for coupon in object_list %}
                <tr>
                    <td>{{coupon.discount_code}}</td>
                    <td>{{coupon.website}}</td>
                    <td>{{coupon.end|naturalday }}</td>
                </tr>
            {% endfor %}
            </table>
        {% else %}
            <div class="alert alert-success" role="alert">
                No coupons yet. Create your first one <a href="{% url 'dashboard' %}">here</a>.
            </div>
        {% endif %}

        {% endblock %}
    </div>
</div>

Da wir alles angeschlossen haben, besuchen Sie http://localhost:8000/catalog/, um Ihren Coupon-Katalog anzuzeigen.

Speichern Sie den Fortschritt:

$ git add .
$ git commit -m"Creating the catalogue view"

Das ist ziemlich nahe an einem MVP. Ich möchte Sie dazu ermutigen, einige Feinabstimmungen vorzunehmen, z. B. das Erstellen einer Navbar, das Anmelden/Abmelden/Registrieren von Schaltflächen usw. Das Wichtigste ist, dass Sie den Prozess des Prototypens verstehen und Ihr Produkt für die Nutzer sichtbar machen. Apropos, unser Produkt ist noch nicht online. Wir haben die neueste Version nicht auf Heroku übertragen. Lassen Sie uns das tun und dann das Telefon abnehmen und die Investoren anrufen.

Schlussfolgerung

Wir haben eine einfache, aber praktische Anwendung geschaffen. Wir haben Funktionen schnell erstellt und online bereitgestellt, damit unsere potenziellen Kunden sie nutzen und uns Bewertung geben können. Es ist besser, den Leuten zu zeigen, als nur über eine Idee zu reden.

Hier einige Schlussfolgerungen, die wir ziehen können:

Die Auswahl der richtigen Werkzeuge kann den Entwicklungsprozess erheblich beschleunigen.
Die Werkzeuge für das Prototyping sind nicht immer die beste Wahl für ausgereiftere Projekte. Wenn Sie das berücksichtigen, ist es besser, frühzeitig mehr agile Werkzeuge zu verwenden und sie zu durchlaufen, anstatt sich in den kleinsten Implementierungsdetails frühzeitig zu verlieren.
Die Nutzung eines PaaS bedeutet, dass die Anwendungen einige Designmuster berücksichtigen müssen. Normalerweise machen diese Muster Sinn und zwingen uns, noch besseren Code zu schreiben.
Django hat viele Abkürzungen, die uns das Leben erleichtern:
- Django ORM hilft beim Datenbankzugriff. Sie müssen sich keine Gedanken darüber machen, ob Sie korrektes SQL schreiben und bei Syntaxfehlern besonders vorsichtig sind.
- Migrationen helfen uns bei der Version und beim Durchlaufen des Datenbankschemas. Sie müssen nicht SQL schreiben, um Tabellen zu erstellen oder Spalten hinzuzufügen.
- Django hat eine Plugin-freundliche Architektur. Wir können Apps installieren, mit denen wir unsere Ziele schneller erreichen können.
- Generische Ansichten und Modellformulare können einige der häufigsten Verhaltensweisen enthalten: Auflisten von Modellen, Erstellen von Modellen, Authentifizierung, Umleitung usw.
Beim Starten ist es wichtig, schlank und schnell zu sein. Verschwenden Sie keine Zeit und geben Sie kein Geld aus.