za-vanila-rnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN:\n",
    "\tdef __init__(self, hidden_size, vocab_size, seq_length, learning_rate):\n",
    "\t\t# hyper parameters\n",
    "\t\tself.hidden_size = hidden_size\n",
    "\t\tself.vocab_size = vocab_size\n",
    "\t\tself.seq_length = seq_length\n",
    "\t\tself.learning_rate = learning_rate\n",
    "\n",
    "\t\t# weights for input -> header layer\n",
    "\t\tself.w_layer1 = np.random.uniform(-np.sqrt(1. / vocab_size), np.sqrt(1. / vocab_size), (hidden_size, vocab_size))\n",
    "\t\t# weights for header -> header layer\n",
    "\t\tself.w_layer3 = np.random.uniform(-np.sqrt(1. / hidden_size), np.sqrt(1. / hidden_size), (vocab_size, hidden_size))\n",
    "\t\t# weights for header -> output layer\n",
    "\t\tself.w_layer2 = np.random.uniform(-np.sqrt(1. / hidden_size), np.sqrt(1. / hidden_size), (hidden_size, hidden_size))\n",
    "\t\tself.b_layer2 = np.zeros((hidden_size, 1))  # bias for hidden layer\n",
    "\t\tself.b_layer3 = np.zeros((vocab_size, 1))  # bias for output\n",
    "\n",
    "\t\t# memory vars for Adagrad - https://machinelearningmastery.com/gradient-descent-with-adagrad-from-scratch/\n",
    "\t\t# ignore if you implement another approach\n",
    "\t\tself.mem_w_layer1 = np.zeros_like(self.w_layer1)\n",
    "\t\tself.mem_w_layer2 = np.zeros_like(self.w_layer2)\n",
    "\t\tself.mem_w_layer3 = np.zeros_like(self.w_layer3)\n",
    "\t\tself.mem_b_layer2 = np.zeros_like(self.b_layer2)\n",
    "\t\tself.mem_b_layer3 = np.zeros_like(self.b_layer3)\n",
    "\n",
    "\tdef softmax(self, x):\n",
    "\t\tp = np.exp(x - np.max(x))\n",
    "\t\treturn p / np.sum(p)\n",
    "\n",
    "\tdef forward(self, inputs, hprev):\n",
    "\t\thot_encoded_chars, activations, net, prediction = {}, {}, {}, {}\n",
    "\t\tactivations[-1] = np.copy(hprev)\n",
    "\t\tfor t in range(len(inputs)):\n",
    "\t\t\thot_encoded_chars[t] = np.zeros((self.vocab_size, 1))\n",
    "\t\t\thot_encoded_chars[t][inputs[t]] = 1\n",
    "\t\t\tactivations[t] = np.tanh(np.dot(self.w_layer1, hot_encoded_chars[t]) + np.dot(self.w_layer2, activations[t - 1]) + self.b_layer2)\n",
    "\t\t\t# taking the dot product between the activation and the weight matrix -- this is called the \"net input\" to the current layer\n",
    "\t\t\tnet[t] = np.dot(self.w_layer3, activations[t]) + self.b_layer3  # unnormalised log probs for next char\n",
    "\t\t\tprediction[t] = self.softmax(net[t])\n",
    "\t\treturn hot_encoded_chars, activations, prediction\n",
    "\n",
    "\tdef backward(self, hot_encoded_chars, activations, predictions, targets):\n",
    "\t\t# backward pass: compute gradients going backwards\n",
    "\t\td_w_layer1, d_w_layer2, d_w_layer3 = np.zeros_like(self.w_layer1), np.zeros_like(self.w_layer2), np.zeros_like(self.w_layer3)\n",
    "\t\td_b_layer2, d_b_layer3 = np.zeros_like(self.b_layer2), np.zeros_like(self.b_layer3)\n",
    "\t\tdhnext = np.zeros_like(activations[0])\n",
    "\n",
    "\t\tfor t in reversed(range(self.seq_length)):\n",
    "\t\t\td_prediction = np.copy(predictions[t])\n",
    "\t\t\td_prediction[targets[t]] -= 1  # backprop into y\n",
    "\n",
    "\t\t\td_b_layer3 += d_b_layer3\n",
    "\t\t\t# dh includes gradient from two sides, next cell and current output\n",
    "\t\t\tdh = np.dot(self.w_layer3.T, d_prediction) + dhnext  # backprop into h\n",
    "\n",
    "\t\t\tderivative_dir = (1 - activations[t] * activations[t]) * dh  # derivative_dir is the term used in many equations\n",
    "\t\t\td_b_layer2 += derivative_dir\n",
    "\n",
    "\t\t\td_w_layer1 += np.dot(derivative_dir, hot_encoded_chars[t].T)\n",
    "\t\t\td_w_layer2 += np.dot(derivative_dir, activations[t - 1].T)\n",
    "\t\t\td_w_layer3 += np.dot(d_prediction, activations[t].T)\n",
    "\n",
    "\t\t\t# pass the gradient from next cell to the next iteration.\n",
    "\t\t\tdhnext = np.dot(self.w_layer2.T, derivative_dir)\n",
    "\t\t# clip to mitigate exploding gradients\n",
    "\t\tfor dparam in [d_w_layer1, d_w_layer2, d_w_layer3, d_b_layer2, d_b_layer3]:\n",
    "\t\t\tnp.clip(dparam, -5, 5, out=dparam)\n",
    "\t\treturn d_w_layer1, d_w_layer2, d_w_layer3, d_b_layer2, d_b_layer3\n",
    "\n",
    "\tdef loss(self, ps, targets):\n",
    "\t\t\"\"\"loss for a sequence\"\"\"\n",
    "\t\t# calculate cross-entrpy loss\n",
    "\t\treturn sum(-np.log(ps[t][targets[t], 0]) for t in range(self.seq_length))\n",
    "\n",
    "\tdef update_model(self, dU, dW, dV, db, dc):\n",
    "\t\t# parameter update with adagrad\n",
    "\t\tfor param, dparam, mem in zip([self.w_layer1, self.w_layer2, self.w_layer3, self.b_layer2, self.b_layer3],\n",
    "\t\t\t\t\t\t\t\t\t  [dU, dW, dV, db, dc],\n",
    "\t\t\t\t\t\t\t\t\t  [self.mem_w_layer1, self.mem_w_layer2, self.mem_w_layer3, self.mem_b_layer2, self.mem_b_layer3]):\n",
    "\t\t\tmem += dparam * dparam\n",
    "\t\t\tparam += -self.learning_rate * dparam / np.sqrt(mem + 1e-8)  # adagrad update\n",
    "\n",
    "\tdef sample(self, h, seed_ix, n):\n",
    "\t\t\"\"\"\n",
    "\t\tsample a sequence of integers from the model\n",
    "\t\th is memory state, seed_ix is seed letter from the first time step\n",
    "\t\t\"\"\"\n",
    "\t\tx = np.zeros((self.vocab_size, 1))\n",
    "\t\tx[seed_ix] = 1\n",
    "\t\tixes = []\n",
    "\t\tfor t in range(n):\n",
    "\t\t\th = np.tanh(np.dot(self.w_layer1, x) + np.dot(self.w_layer2, h) + self.b_layer2)\n",
    "\t\t\ty = np.dot(self.w_layer3, h) + self.b_layer3\n",
    "\t\t\tp = np.exp(y) / np.sum(np.exp(y))\n",
    "\t\t\tix = np.random.choice(range(self.vocab_size), p=p.ravel())\n",
    "\t\t\tx = np.zeros((self.vocab_size, 1))\n",
    "\t\t\tx[ix] = 1\n",
    "\t\t\tixes.append(ix)\n",
    "\t\treturn ixes\n",
    "\n",
    "\tdef train(self, data_reader):\n",
    "\t\titer_num = 0\n",
    "\t\tthreshold = 0.01\n",
    "\t\tsmooth_loss = -np.log(1.0 / data_reader.vocab_size) * self.seq_length\n",
    "\t\twhile (smooth_loss > threshold):\n",
    "\t\t\tif data_reader.just_started():\n",
    "\t\t\t\thprev = np.zeros((self.hidden_size, 1))\n",
    "\t\t\tinputs, targets = data_reader.next_batch()\n",
    "\t\t\thot_encoded_chars, activations, predictions = self.forward(inputs, hprev)\n",
    "\t\t\tdU, dW, dV, db, dc = self.backward(hot_encoded_chars, activations, predictions, targets)\n",
    "\t\t\tloss = self.loss(predictions, targets)\n",
    "\t\t\tself.update_model(dU, dW, dV, db, dc)\n",
    "\t\t\tsmooth_loss = smooth_loss * 0.999 + loss * 0.001\n",
    "\t\t\thprev = activations[self.seq_length - 1]\n",
    "\t\t\tif not iter_num % 500:\n",
    "\t\t\t\tsample_ix = self.sample(hprev, inputs[0], 200)\n",
    "\t\t\t\tprint(''.join(data_reader.ix_to_char[ix] for ix in sample_ix))\n",
    "\t\t\t\tprint(\"\\n\\niter :%d, loss:%f\" % (iter_num, smooth_loss))\n",
    "\t\t\titer_num += 1\n",
    "\n",
    "\tdef predict(self, data_reader, start, n):\n",
    "\t\t# initialize input vector\n",
    "\t\tx = np.zeros((self.vocab_size, 1))\n",
    "\t\tchars = [ch for ch in start]\n",
    "\t\tixes = []\n",
    "\t\tfor i in range(len(chars)):\n",
    "\t\t\tix = data_reader.char_to_ix[chars[i]]\n",
    "\t\t\tx[ix] = 1\n",
    "\t\t\tixes.append(ix)\n",
    "\n",
    "\t\th = np.zeros((self.hidden_size, 1))\n",
    "\t\t# predict next n chars\n",
    "\t\tfor t in range(n):\n",
    "\t\t\th = np.tanh(np.dot(self.w_layer1, x) + np.dot(self.w_layer2, h) + self.b_layer2)\n",
    "\t\t\ty = np.dot(self.w_layer3, h) + self.b_layer3\n",
    "\t\t\tp = np.exp(y) / np.sum(np.exp(y))\n",
    "\t\t\tix = np.random.choice(range(self.vocab_size), p=p.ravel())\n",
    "\t\t\tx = np.zeros((self.vocab_size, 1))\n",
    "\t\t\tx[ix] = 1\n",
    "\t\t\tixes.append(ix)\n",
    "\t\ttxt = ''.join(data_reader.ix_to_char[i] for i in ixes)\n",
    "\t\treturn txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN:\n",
    "    def __init__(self, hidden_size, vocab_size, seq_length, learning_rate):\n",
    "        # hyper parameters\n",
    "        self.hidden_size = hidden_size\n",
    "        self.vocab_size = vocab_size\n",
    "        self.seq_length = seq_length\n",
    "        self.learning_rate = learning_rate\n",
    "        # model parameters\n",
    "        self.U = np.random.uniform(-np.sqrt(1./vocab_size), np.sqrt(1./vocab_size), (hidden_size, vocab_size))\n",
    "        self.V = np.random.uniform(-np.sqrt(1./hidden_size), np.sqrt(1./hidden_size), (vocab_size, hidden_size))\n",
    "        self.W = np.random.uniform(-np.sqrt(1./hidden_size), np.sqrt(1./hidden_size), (hidden_size, hidden_size))\n",
    "        self.b = np.zeros((hidden_size, 1)) # bias for hidden layer\n",
    "        self.c = np.zeros((vocab_size, 1)) # bias for output\n",
    "        \n",
    "        # memory vars for adagrad, \n",
    "        #ignore if you implement another approach\n",
    "        self.mU = np.zeros_like(self.U)\n",
    "        self.mW = np.zeros_like(self.W)\n",
    "        self.mV = np.zeros_like(self.V)\n",
    "        self.mb = np.zeros_like(self.b)\n",
    "        self.mc = np.zeros_like(self.c)\n",
    "\n",
    "    def softmax(self, x):\n",
    "        p = np.exp(x- np.max(x))\n",
    "        return p / np.sum(p)\n",
    "        \n",
    "    def forward(self, inputs, hprev):\n",
    "            xs, hs, os, ycap = {}, {}, {}, {}\n",
    "            hs[-1] = np.copy(hprev)\n",
    "            for t in range(len(inputs)):\n",
    "                xs[t] = np.zeros((self.vocab_size,1))\n",
    "                xs[t][inputs[t]] = 1 # one hot encoding , 1-of-k\n",
    "                hs[t] = np.tanh(np.dot(self.U,xs[t]) + np.dot(self.W,hs[t-1]) + self.b) # hidden state\n",
    "                os[t] = np.dot(self.V,hs[t]) + self.c # unnormalised log probs for next char\n",
    "                ycap[t] = self.softmax(os[t]) # probs for next char\n",
    "            return xs, hs, ycap\n",
    "        \n",
    "    def backward(self, xs, hs, ps, targets):\n",
    "            # backward pass: compute gradients going backwards\n",
    "            dU, dW, dV = np.zeros_like(self.U), np.zeros_like(self.W), np.zeros_like(self.V)\n",
    "            db, dc = np.zeros_like(self.b), np.zeros_like(self.c)\n",
    "            dhnext = np.zeros_like(hs[0])\n",
    "            for t in reversed(range(self.seq_length)):\n",
    "                dy = np.copy(ps[t])\n",
    "                #through softmax\n",
    "                dy[targets[t]] -= 1 # backprop into y\n",
    "                #calculate dV, dc\n",
    "                dV += np.dot(dy, hs[t].T)\n",
    "                dc += dc\n",
    "                #dh includes gradient from two sides, next cell and current output\n",
    "                dh = np.dot(self.V.T, dy) + dhnext # backprop into h\n",
    "                # backprop through tanh non-linearity \n",
    "                dhrec = (1 - hs[t] * hs[t]) * dh  #dhrec is the term used in many equations\n",
    "                db += dhrec\n",
    "                #calculate dU and dW\n",
    "                dU += np.dot(dhrec, xs[t].T)\n",
    "                dW += np.dot(dhrec, hs[t-1].T)\n",
    "                #pass the gradient from next cell to the next iteration.\n",
    "                dhnext = np.dot(self.W.T, dhrec)\n",
    "            # clip to mitigate exploding gradients\n",
    "            for dparam in [dU, dW, dV, db, dc]:\n",
    "                np.clip(dparam, -5, 5, out=dparam) \n",
    "            return dU, dW, dV, db, dc\n",
    "    \n",
    "    def loss(self, ps, targets):\n",
    "            \"\"\"loss for a sequence\"\"\"\n",
    "            # calculate cross-entrpy loss\n",
    "            return sum(-np.log(ps[t][targets[t],0]) for t in range(self.seq_length))\n",
    "        \n",
    "    \n",
    "    def update_model(self, dU, dW, dV, db, dc):\n",
    "        # parameter update with adagrad\n",
    "        for param, dparam, mem in zip([self.U, self.W, self.V, self.b, self.c],\n",
    "                                  [dU, dW, dV, db, dc],\n",
    "                                  [self.mU, self.mW, self.mV, self.mb, self.mc]):\n",
    "            mem += dparam*dparam\n",
    "            param += -self.learning_rate*dparam/np.sqrt(mem+1e-8) # adagrad update\n",
    "                \n",
    "                \n",
    "    def sample(self, h, seed_ix, n):\n",
    "            \"\"\"\n",
    "            sample a sequence of integers from the model\n",
    "            h is memory state, seed_ix is seed letter from the first time step\n",
    "            \"\"\"\n",
    "            x = np.zeros((self.vocab_size,1))\n",
    "            x[seed_ix] = 1\n",
    "            ixes = []\n",
    "            for t in range(n):\n",
    "                h = np.tanh(np.dot(self.U, x) + np.dot(self.W, h) + self.b)\n",
    "                y = np.dot(self.V, h) + self.c\n",
    "                p = np.exp(y)/np.sum(np.exp(y))\n",
    "                ix = np.random.choice(range(self.vocab_size), p = p.ravel())\n",
    "                x = np.zeros((self.vocab_size,1))\n",
    "                x[ix] = 1\n",
    "                ixes.append(ix)\n",
    "            return ixes\n",
    "\n",
    "    def train(self, data_reader):\n",
    "            iter_num = 0\n",
    "            threshold = 0.05\n",
    "            smooth_loss = -np.log(1.0/data_reader.vocab_size)*self.seq_length\n",
    "            while (smooth_loss > threshold):\n",
    "                if data_reader.just_started():\n",
    "                    hprev = np.zeros((self.hidden_size,1))\n",
    "                inputs, targets = data_reader.next_batch()\n",
    "                xs, hs, ps = self.forward(inputs, hprev)\n",
    "                dU, dW, dV, db, dc = self.backward(xs, hs, ps, targets)\n",
    "                loss = self.loss(ps, targets)\n",
    "                self.update_model(dU, dW, dV, db, dc)\n",
    "                smooth_loss = smooth_loss*0.999 + loss*0.001\n",
    "                hprev = hs[self.seq_length-1]\n",
    "                if not iter_num%500:\n",
    "                    sample_ix = self.sample(hprev, inputs[0], 200)\n",
    "                    print( ''.join(data_reader.ix_to_char[ix] for ix in sample_ix))\n",
    "                    print( \"\\n\\niter :%d, loss:%f\"%(iter_num, smooth_loss))\n",
    "                iter_num += 1\n",
    "\n",
    "    def predict(self, data_reader, start, n):\n",
    "        #initialize input vector\n",
    "        x = np.zeros((self.vocab_size,1))\n",
    "        chars = [ch for ch in start]\n",
    "        ixes = []\n",
    "        for i in range(len(chars)):\n",
    "            ix = data_reader.char_to_ix[chars[i]]\n",
    "            x[ix] = 1\n",
    "            ixes.append(ix)\n",
    "\n",
    "        h = np.zeros((self.hidden_size,1))\n",
    "        # predict next n chars\n",
    "        for t in range(n):\n",
    "            h = np.tanh(np.dot(self.U, x) + np.dot(self.W, h) + self.b)\n",
    "            y = np.dot(self.V, h) + self.c\n",
    "            p = np.exp(y)/np.sum(np.exp(y))\n",
    "            ix = np.random.choice(range(self.vocab_size), p = p.ravel())\n",
    "            x = np.zeros((self.vocab_size,1))\n",
    "            x[ix] = 1\n",
    "            ixes.append(ix)\n",
    "        txt = ''.join(data_reader.ix_to_char[i] for i in ixes)\n",
    "        return txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TstzAwBpzs.BhwT!\n",
      "odvyW sR.-WjRisWPWx/Y sB)P)cjS)lrppthPtcmNsus!zRC !PsoiIdcs?'ppkvtNIrmlPa-aqulYll?rz,qLPsu.pcntrsTWSsbL)!,gC?-NRqP'IL s/ci-jo-ymcvs sglebcedgYrwU,fyT?SI',Il(PmigjsrTwg sUia)pi.d/sPcB'\n",
      "\n",
      "\n",
      "iter :0, loss:98.295346\n",
      "h ne hnpss ahahey insald int, Cl iod ure uoepmhe ngen an unduudamaic ainyas ani r no swuralotn ac fe sd \n",
      "iltangha.\n",
      "veoterys yhe cldamisoscd  aft asfacs soshaar lapi Isfe d cwrt idus fl aheaNniuuobeac \n",
      "\n",
      "\n",
      "iter :500, loss:90.726713\n",
      "euc fofescek cof whals couurs babomd \n",
      "nfeilfecrecone raceriod mhamyxur er'ov sibleng ss tonnts.\n",
      "\n",
      "Whde Psctsyan judet tolondsisillcdexeevinton?ef mconinung sed tioneew inncersmor vkonctoothe Ptonr wexf\n",
      "\n",
      "\n",
      "iter :1000, loss:79.686091\n",
      "nmpr thesh /wit mucthe tom.Tvis ws, doct nl arye genres avesd pod plaminis tactuante thar sitedlapteRd conthis ebuton tometars to q m codd ers urchemponer ramure thy intos y is sly bere pesr that to a\n",
      "\n",
      "\n",
      "iter :1500, loss:69.953882\n",
      " cveasctang furh bfeapeftsyonk on ritowe ka uclindtotstary ouplo checepitdersi-g brounentpruty. Anof cj mumruntidicuve ?rif com? yhompl wkcotedotext bile anta ilext mracny and acond cobderuBy kpurong \n",
      "\n",
      "\n",
      "iter :2000, loss:61.706081\n",
      "forerd.th wk woth osstobrofwied arary o comphit cexth yo spefed thep lasher auct pofacoh thew tu mracingt fode cofled amp mf\n",
      "ctapust copendead as tu he ghessingie thems murang boghat Bomgeand comt?it \n",
      "\n",
      "\n",
      "iter :2500, loss:55.072589\n",
      " thy usito Prethees tofy ucicher,t prethechetond ose thif iosimnags and coneed tewy thi fempest, sont shamale mects muclawe rerolyof th ceftible.\n",
      "Cowefas fo poully thew, tint ye,t ptle Prollofesd .\n",
      "\n",
      "T\n",
      "\n",
      "\n",
      "iter :3000, loss:49.567379\n",
      "pous sulled ps.\n",
      "\n",
      "YIthan chaed couryip he shing oupllis or tompoige that craore codmer ther\n",
      "hes, apwlerencsienents andearle componendeterithe strerhin componensteructnacly copsinn ot ef ined wenkstrero\n",
      "\n",
      "\n",
      "iter :3500, loss:44.805796\n",
      "We tanos, ao themat intore ing ialied soganictstandiclebe.\n",
      "\n",
      "Cou camrof woul cinted.\n",
      "\n",
      "We nerfrithengs aos thoucte isiollicos youp wase stald wlis onects onaseIs dode lashestestianey cory pole ithe tare\n",
      "\n",
      "\n",
      "iter :4000, loss:41.214656\n",
      "intfor.\n",
      "\n",
      "ItLomfolle ony sog in sith one sige coderssat turt, aln is wog.\n",
      "\n",
      "\n",
      "Low in mu ur ancodefonntait then iapl ba ep in mutonllit poneccohesesstontstent, ithe couponenterat ba ch bheate she nonen to\n",
      "\n",
      "\n",
      "iter :4500, loss:37.823203\n",
      "pent, wrofrof cublext fompones ther ang -uof ding muct aruof wis in tu and paskes over Pfe foam.s thinct, unper cofopy the sh pleccinerR y sing; kears comeectithew chat is ale asle compou; ie wnche gh\n",
      "\n",
      "\n",
      "iter :5000, loss:34.949139\n",
      "errard pustearo amt ines are mhould contefr tage ss anlaind coumerSideas omr ir, and.\n",
      "\n",
      "What codeaclempothing oupnt cant, steraas of in digery.\n",
      "\n",
      "The bavictest he y ererced thac inte sinsitkiglenthed th\n",
      "\n",
      "\n",
      "iter :5500, loss:33.266347\n",
      " afriche thim ofss, subloul cohe und mass to unth Nodectly. eter aud component concelys tige components ther cou frompowethar chang clare poould bhow coching code aling ghew tofilliche rodund.\n",
      "\n",
      "Thesio\n",
      "\n",
      "\n",
      "iter :6000, loss:30.597729\n",
      "e foms corke. The rode aritn ave in wotleag acces turkcodeitheks arr cfodectsmalw entoun he angesis sig sowe ing muctepthec toty illing. Rep carcoutlinn ef coup cave botecd pr pectasilied ais yos arce\n",
      "\n",
      "\n",
      "iter :6500, loss:28.189255\n",
      "n comure thing er conth coly yon depr foup codetktsithelr sued ae dofficle stmion intesit. Ceats a/sing miley cussinge sing fintewints cthecoore sistsersistes orpest, and ro itor eve araterill it chat\n",
      "\n",
      "\n",
      "iter :7000, loss:26.346259\n",
      "t dloull if ces enced aapling. lepren boureth ou dhykithe Simuel cont ma benclle cont re\n",
      "t orfeching Bas esuroungito Coutos yod wouthas into boug wy ither?od that thingy sucomyonestohe as main youmer \n",
      "\n",
      "\n",
      "iter :7500, loss:24.638581\n",
      "pes oull trof oraveructSinoted.\n",
      "\n",
      "Tho ?h fer inop edore cooreatscorreaply ifory hou dempthe seftcon weved, wout cait ient os dis ompthand corutor ipersit.\n",
      "\n",
      "W aveler overr aces the cohess.\n",
      "\n",
      "The pext ing\n",
      "\n",
      "\n",
      "iter :8000, loss:23.061587\n",
      ". The goun ally theain baog depent faoge ind deal ha lore sigh cthes, corm?ealedenges tayl Ba reale ind of neer to ary thay inge thyoun ed poth tuon enderposs fochlrize dy went conte\n",
      "Products.\n",
      "\n",
      "Whe na\n",
      "\n",
      "\n",
      "iter :8500, loss:21.609635\n",
      "to khoglectiSP thacstot decung mhom cearly arsull-d paveas emponenctortibly arint coupesion ther wery intody sould cspen semy compeng\n",
      "\n",
      "The on ouc It concepssswot bas cha s to wee s ments in untoctinuc\n",
      "\n",
      "\n",
      "iter :9000, loss:20.145156\n",
      "g.\n",
      "\n",
      "When ap tore the componentrowlling bou deab tomponenas is Bkall cell cobetRes oncod umpestry.\n",
      "\n",
      "Cour couply wound ysqwit. Thould anctiep dea s aec bouwing ances onto theite rapkallyon ther? cote.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :9500, loss:18.820007\n",
      "res ave sohe isstig forslaas one ether wable sserrountiene pamponextsha fomponentsithit.\n",
      "\n",
      "Pderind aone canvere youle that coduptay. The code the shoule the race that. \n",
      "Thenals supknowlinge ticublentec\n",
      "\n",
      "\n",
      "iter :10000, loss:17.964852\n",
      "aderes ane you dround ald llammectsy, tige that rhapl cosully in\n",
      "mpes? wear cooverreany enthaint th asither thim thy sitod, y.\n",
      "\n",
      "The yest, wrothe sivery ptery upr fop marconend aoreac inge couprcount e\n",
      "\n",
      "\n",
      "iter :10500, loss:16.792694\n",
      "es s yssteade ns plecsint that cemreconsiforerpes mofere s, yry stawitorrexs bit Pfaist at troul arconterface, ssog pontexts wor archil -e. Priareaded.\n",
      "\n",
      "\n",
      "Thes cnow musiss youlict tint camklyo jogeft m\n",
      "\n",
      "\n",
      "iter :11000, loss:15.970713\n",
      "e ro uribusiand copurfaces sup shing bpever incep thes.d The code, terethog. The definge thather Bosthieg. Usel wncowlenckass together, dave toblic inte ingale bothe stcapk amuthie inoune, as ontestro\n",
      "\n",
      "\n",
      "iter :11500, loss:14.861293\n",
      "e ancems o whes th maly or;er em ine, wout annoinly ercerhe Rpmaintiin if wict whwinved ompont y urhe anced op in mucinh cuatu smacle thake recssien youl conterIting ffapling lfower loupls correct biv\n",
      "\n",
      "\n",
      "iter :12000, loss:14.112632\n",
      "u noge cons moductiblll ais axt xall aricfere frpurt cuinted tann a nompodedective ti reakspontogeting tsyou hero. The codents warulien to unde.\n",
      "\n",
      "They iodether.plit. The crams abpouple wuth overurithi\n",
      "\n",
      "\n",
      "iter :12500, loss:13.589564\n",
      "tibgers sifry hep is evublrom ars accenend atsith ou the story is access tohether. Coverinc coner incend poratreacins te with other, on conts anged co cevery pave in cosither, pothe Ithy urfecresh ith\n",
      "\n",
      "\n",
      "iter :13000, loss:12.854649\n",
      "atss correst Cou need or eronte, arkak sof inod tamponetronn tespesgling gedy pode courests over ehe thoup compodem? he pang tove reataskesstibly intaint wethy and uncoms,oblingar foncendepthefling an\n",
      "\n",
      "\n",
      "iter :13500, loss:12.128023\n",
      " camponents onge it yound maintain if ur themponentarill conces tanly conally urct you need of wing angemponentaing with e coderctarlyd ro underyone mais contay ssald feat inged omponents evind Ie any\n",
      "\n",
      "\n",
      "iter :14000, loss:11.538680\n",
      "to makeve compocenthit wucfor dogh conctestshe lesronde.\n",
      "\n",
      "The bacess, susit maquld ProductSessento component. Paible yould mew inte peptien thancesstating uapy ofupls fos ore nod ibound sigh component\n",
      "\n",
      "\n",
      "iter :14500, loss:10.972174\n",
      "nRe the po ble his ousing on the component's purays commones domacthe Sod feme, wound poce merobethe stheryody arka gund if concofry component oreaced wurchess on th in inge sialite Nony isig tlet xys\n",
      "\n",
      "\n",
      "iter :15000, loss:10.370983\n",
      "ofebrive testsRef muk po esitisly )r evenic aliblic Primeratkit pofperathag  ffacs coucrall on wery ang I how couply he the rack that.\n",
      "\n",
      "The basic sumssis ofpor enctible should o forer ingepcont.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :15500, loss:9.799914\n",
      "idit. Protu.\n",
      "\n",
      "The basisic. The contibly ind mow coupl-derory medr on in woulents. The the nhars todelt mespontain all common wly und iave inteclerants. Nothing.\n",
      "\n",
      "Thenge pom cou dia d sucon th oh compo\n",
      "\n",
      "\n",
      "iter :16000, loss:9.157339\n",
      "tes commerow coru cofurpilents.\n",
      "\n",
      "Ideadesis.\n",
      "\n",
      "he jame storec codperant wyour Itary tone hanc suthess sifuctari to enos. Bs o rext arryot ances ta liogether, shargesurigh tortext iss ilef wom to the the\n",
      "\n",
      "\n",
      "iter :16500, loss:9.266659\n",
      "e seadlenter nowitved fompung patins toat of nlepll conteig foffecle are unound atnound and maintain if won entess, th enderroflede\n",
      "\n",
      "Whe stses thy. poge yhegether?\n",
      "Product the foner ingallest of cos s\n",
      "\n",
      "\n",
      "iter :17000, loss:9.511817\n",
      "e athe d med seag cole inforerifss as andsilarrer smapst ed he understand and lom tigh if surd achor is code ant, sn wly wric intorelly estand kour coduct Bhqubi he tompos componesta lreall inte compo\n",
      "\n",
      "\n",
      "iter :17500, loss:8.717499\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " wig. ghacs.\n",
      "\n",
      "Couly chably The to rapkit! Prisitecthe deat ifryog ef costory urict wicuer ances th cout hew coupled objects.\n",
      "\n",
      "It's essentis feneabi ef wot n. Papr arp ive urpestry chaud innes to the s\n",
      "\n",
      "\n",
      "iter :18000, loss:7.994152\n",
      "d ampeng. \n",
      "Bhaing. Usely mespon anc interfacykogetoryobly iching Pracing ntote herent.\n",
      "\n",
      "The basic sumucisn es beat im ortint youg to arisiche shor levest.\n",
      "\n",
      "The baclied annes toge he orger andest amror\n",
      "\n",
      "\n",
      "iter :18500, loss:7.884059\n",
      "messs geting yssorporeanid beverestaning booutestiog components onces Nath puld cont of eeve and Productvesitien is the nade ssurlecentep suly sill of ision mofteass.\n",
      "\n",
      "Ite, pod pestext of inces to he \n",
      "\n",
      "\n",
      "iter :19000, loss:7.325379\n",
      " cane bas of graw.\n",
      "\n",
      "\n",
      "Low cyiw shams the ate.\n",
      "\n",
      "CouPrind Bfouctthy tour pontions stew. Use would gequlicg tosith ithes, stors to hace. Iued for loare rode weving oritotect, Product efos to wieg.\n",
      "\n",
      "The ba\n",
      "\n",
      "\n",
      "iter :19500, loss:6.873556\n",
      "mpllic ing public of cofry a?nend for aver of coup componentr inseve and compose texts wewis sull for lowic. Borvesisit mative tay. Ithw tould he- toage components.\n",
      "\n",
      "Wher aon coduraisis and indepther.\n",
      "\n",
      "\n",
      "iter :20000, loss:6.869777\n",
      "gext puple in thy.\n",
      "\n",
      "The bave bes esses sery nout your acterelta sigh component es aple thoun\n",
      "Be chans aoce smain if ylacyexts.\n",
      "\n",
      "The basic summarces sif no cenether lout ant Bour code thy wound surfacs\n",
      "\n",
      "\n",
      "iter :20500, loss:6.267354\n",
      "asts on yovict musp unders components.\n",
      "\n",
      "Whe, spone hau tha inge nasidg ma, s ane commerhapl ined ablit conte context from conteracts with other componeptshecthrurine that conce that how mallyidt ondll\n",
      "\n",
      "\n",
      "iter :21000, loss:5.999473\n",
      "idera siag om on isead wny components oncer fecthes to Chousitigllyot.\n",
      "\n",
      "Nher, ercore cod unt. Prithed pabliald fuchive to teane ro ary compomentro componen abitesion contain ald infecturall oupthar in\n",
      "\n",
      "\n",
      "iter :21500, loss:5.725167\n",
      "esio/d. Priorero underotheas arr of cooperathingef cempour enthe stout inoup iog the codert, and ProductSexpriflectSpof in the thowituctsisiquly unce.\n",
      "\n",
      "The basictss,obiting os on interacts the story i\n",
      "\n",
      "\n",
      "iter :22000, loss:6.470188\n",
      "e esponsiger correyly.\n",
      "\n",
      "The basic summere re components clearly annound all cent itvery nverses common haing fublic sucil coupd dec she cings.\n",
      "\n",
      "Thery Resibgly uruct context ang ProductReposmancess one\n",
      "\n",
      "\n",
      "iter :22500, loss:5.912945\n",
      "eryog bod pou loflit. Pra sing or iner axt irpull chle compompos intass pomalingest.\n",
      "\n",
      "The basis surhe yofrigeb evenald bourext eruiterstorats fim filp y athar es wuct and Promucly hrigen stone dest, P\n",
      "\n",
      "\n",
      "iter :23000, loss:5.361676\n",
      " why shar ingenter, puche and our oucta diat th urh cound and poplerchin. The rest atlyowler?\n",
      "Ptiog te sisus sists betiot of orempended pall ic wethyr.\n",
      "\n",
      "\n",
      "The ama sund concther to Cooget.\n",
      "\n",
      "The code thy\n",
      "\n",
      "\n",
      "iter :23500, loss:5.034258\n",
      "fid kears fote t ge the name testey codeting osuthle y mompos of or chathe suml che sigh of oner context from other.\n",
      "Thes that knonlect camp, grat yout pain if cullary complind les mare ro or er une. \n",
      "\n",
      "\n",
      "iter :24000, loss:4.630391\n",
      "plioge correctly. It is togetiqgetion th tecom maon interface he desests.\n",
      "\n",
      "Logesitatest, pur areve is amsopwhe stery ark uadesss ehey chaint one coded thin suan youg to mame seate, cohesyout covering \n",
      "\n",
      "\n",
      "iter :24500, loss:4.670691\n",
      " sems, bounded conog thives anc sullice. Yoverion conthou che sisisig sif!wy, wint your code poull-ding led oule derengiflet, andes todell-.\n",
      "\n",
      "The basis duwict or interconces cospur cavion the sisige i\n",
      "\n",
      "\n",
      "iter :25000, loss:4.634229\n",
      "or erce. Yog moup interoos on yog boungari inge. Uulicined destextiod inte you nede a sunist yogepriflect, ProductService compoce, and poriere noreereffrcorvic pumlored turinit inow annse that coore t\n",
      "\n",
      "\n",
      "iter :25500, loss:4.215022\n",
      "g/.\n",
      "\n",
      "We nnterface hes to under, wing gebot encontint Basestanl iily cos compone caas esur coupling Cour ponendinn offrang of comsterats of ine. Pront dew akcesss.\n",
      "\n",
      "It's ro reale (SRP) andeplasss cones\n",
      "\n",
      "\n",
      "iter :26000, loss:4.029006\n",
      "oupdets of inew smak mornectsink utusts the node. Ithot componentsit if yoncances to cratige that will ende cohe Rerpos compund yofledg bopleblendebat thing of cint if yoreatestivelt the tomposithe st\n",
      "\n",
      "\n",
      "iter :26500, loss:4.674246\n",
      "ed modusk dings gotedint to. \n",
      "hait kovet.\n",
      "\n",
      "Wethe's of cing tovecasses and contexts.\n",
      "\n",
      "What cans defingem to Chec prucled ithed of betess pimof to tha sint contexts why, rhe bepleare hemter.pling m or e\n",
      "\n",
      "\n",
      "iter :27000, loss:4.870225\n",
      "ting components complivitaily ing to understand and maintain if we can effectitepti roflect, ahe chepledetRes acceme component's mpout will ouct ancomrisisgestad fourle stu yourfices hige, ing pubgill\n",
      "\n",
      "\n",
      "iter :27500, loss:4.494185\n",
      "e Noth ingebler coupling fremporghongether, cancof isic inte commofledw of ro ensifses edrorropleacdusucund tunin - the code that is.\n",
      "\n",
      "\n",
      "Cheenterstestoup a hu Nhant compodent code thy conces thapl comp\n",
      "\n",
      "\n",
      "iter :28000, loss:3.863481\n",
      "e annoss oute nhe noo mamponetay thia sif pedill aint, Pracssmances together, stays to whe stsef e urrect, and Pfugha sim! Th wlit The code that serves a commlove arcouru the codents yom dacrey samkis\n",
      "\n",
      "\n",
      "iter :28500, loss:3.458815\n",
      " inhe ancod omponents clearly and oullith un? It wied and contrig punle hever inon ere are components oncode thy stexe subitebine. The about thow ons cunk desponecoss mamponeness of er in wegeas youg \n",
      "\n",
      "\n",
      "iter :29000, loss:3.467301\n",
      "d amponents onde to tog coupls coure in tige tactext es compene, at pouc a niges morhe urh conces th code togepinnates that consills ext arr ic inteckaserssit. rompes murp cungs.\n",
      "\n",
      "The basic summary of\n",
      "\n",
      "\n",
      "iter :29500, loss:3.814566\n",
      "pliteet, whew therything public! That.\n",
      "\n",
      "The basictests.\n",
      "\n",
      "Ide shat will end aply annole tay thing of cars in togetig endo that is why coded.\n",
      "\n",
      "The to tog components. It meens esusitod oupones.\n",
      "\n",
      "It' suff\n",
      "\n",
      "\n",
      "iter :30000, loss:4.074614\n",
      " decodrealetls y comptrercourkagle steare romponentare indert, and your ced pode things get much easier to understand and mainey urfwcumathd.\n",
      "g.\n",
      "\n",
      "The chep if caplere, w whawsinenst efit, couc sew couc\n",
      "\n",
      "\n",
      "iter :30500, loss:3.497802\n",
      "or even replaced endapseas of coffengefic interface, covering ever, ancondenas es abies te uns corsigh cohesk, apout tera code that ws whe storka ur enon controtu beves the have underes components.\n",
      "\n",
      "I\n",
      "\n",
      "\n",
      "iter :31000, loss:3.046978\n",
      "gext wou lleplackeaus to understand and maintain if we can effectively hrfectnhe more restricted your access leved, ats componenatithit ourg be copthe urkad ?hep lr ario le story couct ancof medre foa\n",
      "\n",
      "\n",
      "iter :31500, loss:2.728956\n",
      "efts the codewtr the codest, and des, as essestinly cod ances to crass, wy urha ie wle coucderastige tevect, ProductService, and pupling ureffocests ess or ifor corieve sle eagssor eve abent youl, Pro\n",
      "\n",
      "\n",
      "iter :32000, loss:2.514948\n",
      "ade togy mucthy accans to onterconsed interconges of interand penes to are er ifod thec.p sall The components cllecoures auply concext is.\n",
      "\n",
      "Thept dupleting de Coupdedribl unhere, and kour code ann the\n",
      "\n",
      "\n",
      "iter :32500, loss:3.976409\n",
      "esitg.\n",
      "\n",
      "The next of caplet enth alite, s ance. Yourkanne isstiglwito nnestes, wew code thy un chacle are sucum bovertext ins urliced meprevill und pomponents wize y hestexts.\n",
      "\n",
      "The basic summary of the\n",
      "\n",
      "\n",
      "iter :33000, loss:4.587420\n",
      "e to wicents one code that sem, annod of clder, writhe thou dofendentict ancos texts feco. Yowlem that thing you dewice. The pothit I howy ur if aro cod warrogett bothevibly testrefteranntessestaccese\n",
      "\n",
      "\n",
      "iter :33500, loss:4.091464\n",
      "e annteit Inged ibit inour context from other couthinge siover components onces the wilic. The code. Your commpondeag tige lere. Yowrectests.\n",
      "\n",
      "Ies esique interfaces she tondeplaces wige the forefing d\n",
      "\n",
      "\n",
      "iter :34000, loss:3.348609\n",
      " ghy und purling. Apply the Single Responsibility Principle (S\n",
      "Ihe, (h ir lyatem that clas esurper of codectsse. Cohesint and contes th, concer to ino evecilly tm?Pr components. It boged context in to\n",
      "\n",
      "\n",
      "iter :34500, loss:2.892092\n",
      "t yoned or im ontict wous toly yr chitecture daag the domain knowledgy. It mercsuon of ing. It a sif context fryou hand compone, and of ciady tunt Youl, your poductSerory pred inleve wighe sther coble\n",
      "\n",
      "\n",
      "iter :35000, loss:3.057478\n",
      "wnc mmonntstand annonectsion cocour jubl if inveres ompose wering on wico isgemsteblyain ingllw of be angefor to ino rooge cofry ancun tadd or il aubgle thaslwith ruel orro ule covel, ats of gheve thy\n",
      "\n",
      "\n",
      "iter :35500, loss:3.001656\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " inhe ances to int ges ther on the component's public interface, covering every pams, se together of cave intorell-define basi iss uly gecos anga siflet cforests chat ing puple in chicterficy ofly pou\n",
      "\n",
      "\n",
      "iter :36000, loss:2.758505\n",
      "or er yow change con efurg annting The code. Your code should reflect the architecture diagrams to apmala duchly would beving fow comp cemaon coplepls in tith that.\n",
      "\n",
      "Then mon? Nothing. Both an. The nh\n",
      "\n",
      "\n",
      "iter :36500, loss:2.369322\n",
      "T.\n",
      "\n",
      "The gath lesting\n",
      "\n",
      "The code thyos she components andlitvinit of interand kesplings get much easier to understand and maintaid kohesion. Use well-defined interfaces and inversion of contains es copm\n",
      "\n",
      "\n",
      "iter :37000, loss:2.112299\n",
      "efos the story is th ing druplin wn inces to create unnecessurs on thy wig. Apply th we tha sestes throurom iaciss wondeg.\n",
      "\n",
      "The basictestsponed interfaces shit wouk fryithyour patr ave arurectlit of a\n",
      "\n",
      "\n",
      "iter :37500, loss:2.359357\n",
      "y, why codewitin. The and cones and iour hoderictmrap enterface.\n",
      "\n",
      "Then, instead of writing unit to makies componeptint Bastext fritly cenderasket ancests cimple ianth connt entle lou components clearl\n",
      "\n",
      "\n",
      "iter :38000, loss:2.751135\n",
      "esitg - the code that is Prackaresie d. g.\n",
      "\n",
      "The chans to are uapemary thave deflet, paig arp if cunpritucthes together, cais code. Your code should reflect the forpested code thyourh o make to ine nss\n",
      "\n",
      "\n",
      "iter :38500, loss:2.629166\n",
      "w es ssucly cis shams wout impysint ilcine it eaty and wess for every publicent, wubitlif cofullit. Prohit. Prowinn sige tast beat you have undeplasies wing ysuthing on the context froup cevedurith on\n",
      "\n",
      "\n",
      "iter :39000, loss:2.252973\n",
      "e annecturacosessessaccess you de coount dur. cendent comply me poserperyour, ined the component's publlaces sha d foutext ang unitlycondes that thinistewit toupling mearebinde cone Id gneld, wuct en \n",
      "\n",
      "\n",
      "iter :39500, loss:1.950701\n",
      " gh entext aru unly thew, and contexts wewitve itRef compose tiy component depends on or intera as, depontexts weructshe simponectsigntitly lrigly pleprery hmain ald bann bo enses the ro Repring the s\n",
      "\n",
      "\n",
      "iter :40000, loss:1.752108\n",
      "d mumkofetedtion of codprinl cores surlycenda leasis ing duprevities esurka jucp thats comebined masitRepontay s component's public! That deplace. Cogubite ramp ur over os contexts he ondepontay s cod\n",
      "\n",
      "\n",
      "iter :40500, loss:1.687706\n",
      "aknenters.\n",
      "\n",
      "Cotemat coundari if your arching of siflec, tall heat xm the ssurfine rects onces suthy domain. Piogye, commecompone th unlede isterp innt. gher avely is amstReresithe code that bile youli\n",
      "\n",
      "\n",
      "iter :41000, loss:1.582847\n",
      "d interfaces and invedy ancorel shes contid oun motesicis condeatictestexts.\n",
      "\n",
      "The basis le th unatropler, prameess bouce derenthit if yund onogether, stays together, carefully encenss.\n",
      "\n",
      "The interconne\n",
      "\n",
      "\n",
      "iter :41500, loss:1.469446\n",
      "or er yow compoulit impont your actexts mumm, sh temt, Prod centReposising is our for andepthes. Cobleysto enonderavingro boflyctRepromponnt. The neres th you ghouple steasier to are components cous a\n",
      "\n",
      "\n",
      "iter :42000, loss:1.599207\n",
      "he components to prefepone winer anderaties ch madd controouss.\n",
      "gIthesstnot componens foder rofres, ancod offerit hew puplis ing dfow inged onceptettiblyain if we conces th cohstar e concostowges cont\n",
      "\n",
      "\n",
      "iter :42500, loss:3.717906\n",
      "eve urcode anu meverain all classes abor or high cohesion. Use well-defined interfacekr, whe enorlererstand and maintain if we can effectively draw and enforce boundaries during de. Ches sigeb iver or\n",
      "\n",
      "\n",
      "iter :43000, loss:3.828773\n",
      "it freplaced sifingy.\n",
      "\n",
      "We nacr mamion adlinne nofly kvasion to understand and maintain if will context from other of ing.\n",
      "\n",
      "The decon ant thin stowlent, do anes to understand and maintain if your incen\n",
      "\n",
      "\n",
      "iter :43500, loss:3.030470\n",
      "esitg. \n",
      "hec sullis that cons kas esion ye coffeconematnealagethed objext wsur. Bote compomponents.\n",
      "\n",
      "Then, instead of writing douk.\n",
      "\n",
      "Then, instleall cap anied to make errer inforc med thingstow, yos mm\n",
      "\n",
      "\n",
      "iter :44000, loss:2.392685\n",
      " ro just bour coduct your code and with unotiention ant code that will end up in ad pledentsgeplent, whe Resitory have in common? Nothidg chas inge tha dependeresing on the component's public interfac\n",
      "\n",
      "\n",
      "iter :44500, loss:1.970568\n",
      "e annes to orating ysuthe dompos cave into and ot incereated.\n",
      "\n",
      "The essertody the unfadyopley. Pact and itogetis such easis on or lighe The codebt, and de. Comact conted ta pod of components clearly an\n",
      "\n",
      "\n",
      "iter :45000, loss:1.684577\n",
      " knhepthe cthes tnow tadd popent's erorcodeddeponingacs foreade siat or couth inger to understand and maintain ingent components.\n",
      "\n",
      "Ideally, we sseasier to maky codithergwinn ald and lothe othe togleat\n",
      "\n",
      "\n",
      "iter :45500, loss:1.602371\n",
      "f wompoching one components andis wot wode ent's masit boundersepot aaykess cimply concepcove th wowet anlaced withouss ay high anit aod of cones wit how ouche dofented pomponents onces that your pont\n",
      "\n",
      "\n",
      "iter :46000, loss:1.450271\n",
      "pliceextn.\n",
      "\n",
      "Then, instead of writing unne till icos, context and only provide access to other packages thrount correct yould betiod overy publices onge, mpone, and muhe lere thass cons of iner ao tore\n",
      "\n",
      "\n",
      "iter :46500, loss:1.328664\n",
      "y sifly th wy components.\n",
      "\n",
      "Idearly, po everatisys com inon torrealetes ais ins utly could ais juch esuche unceacthewyrcess, suma, and unnen that thingstew the story is that thing webit innt anc inte c\n",
      "\n",
      "\n",
      "iter :47000, loss:1.262629\n",
      "or even;.\n",
      "\n",
      "Ides te inouns mute the code that serves a components. It means one components clearly annogeto nasies masiting ite coded bodefroblaclede togeting bact as for high cohesion and low coupling\n",
      "\n",
      "\n",
      "iter :47500, loss:1.440062\n",
      "gThe pomponene.\n",
      "CWecconend win. The am bog dewibit ed cupleareas on sige context from contamind interface.\n",
      "\n",
      "Then, instead of writingle wonlede isit. Choupled ro mefrofleccha changede icilly thew thit \n",
      "\n",
      "\n",
      "iter :48000, loss:2.527226\n",
      "as orepoential toup ann muchith y.\n",
      "\n",
      "Che ithe essentiand or intarievifurnon tayks of cooperathit contexts we the fowering ysuthed doftwilecod shewsiondefiner are is togetige le endepllacleraineld allay\n",
      "\n",
      "\n",
      "iter :48500, loss:2.574529\n",
      "wine derriblly pepes thew ciagever mor? at wricit your couctse plealy consifs andes to craes come, and such a unit do just that.\n",
      "\n",
      "The basic summary of thaystrery ving that.\n",
      "\n",
      "The basic summary of them \n",
      "\n",
      "\n",
      "iter :49000, loss:2.124124\n",
      "esinge innork thang I omponents clearly announces their purpore, cohesion. Use well-defined interfaces and inverais abnendarreal the components, onosit. Choulg for eraid courith ount ofracen elelit pa\n",
      "\n",
      "\n",
      "iter :49500, loss:1.734190\n",
      "y (hain to ent with for high cohesion ing decturas sis. The name cther, thieg to aribull- entarit youp ind pure rabo thasly and intebfechif we couge that chaver of yowit amstsyourpy prould of cing you\n",
      "\n",
      "\n",
      "iter :50000, loss:1.470072\n",
      "e and oned concexd.\n",
      "\n",
      "Lhy yould menas sucthe other components.\n",
      "\n",
      "Ideally, we should orang reat thevects cos covectint do underess antams in tito younded contexts.\n",
      "\n",
      "The basic summary of the sssunled prog\n",
      "\n",
      "\n",
      "iter :50500, loss:1.291329\n",
      " conery pund coure that wo knoull and our overrompos turp intosithec, conthed annese component rour access to othen tunt ine iaverk on wiad thaint ontent Pa mughe spour. Pingres componentace that will\n",
      "\n",
      "\n",
      "iter :51000, loss:1.175975\n",
      "tithe that onepin thass cung bo the code that changele is ans toupling. Apply the Sing bourhited corieve sterfecestang poupling mabling meflectest component d. Pany that is wiog tubunitlicent componen\n",
      "\n",
      "\n",
      "iter :51500, loss:1.090874\n",
      "ats oncode ang ther components. It means one depylit wne stose ibo invery ppemt.\n",
      "\n",
      "Thever iogerstand and maintain if we can effim context froup ing. Apply thy wether stays together. The code that serve\n",
      "\n",
      "\n",
      "iter :52000, loss:1.083722\n",
      "it couting os of coure smarle basic summary of the story is that thingstewit ene. The next in. The enonde cempos rawy and maintain if yllcompocemars iever, insillly unt pamptionsiss snogy able the isi\n",
      "\n",
      "\n",
      "iter :52500, loss:2.897755\n",
      "or even replaced without tad bluckasion the ractuys boryine thes the component depends on conteit IuRPrion om on is a sunkllr oncos to inte argef ciplerentibly insstend blic. Checko unces ancess mars \n",
      "\n",
      "\n",
      "iter :53000, loss:2.706079\n",
      "TRep tounded irg components once tout code as beginners frameweratssebothe thy sure boun ae the compore, componentsrally, re the codeles ofeacing cout tewry concess oubigle Responsibility Princill ren\n",
      "\n",
      "\n",
      "iter :53500, loss:2.116182\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "est different problems, so why unict ofrerothe isued arrillrcoup that code und midd overres components.\n",
      "\n",
      "Ideally, wewsis context and onders and much more readable.\n",
      "Pthe stotithy hour inderacth woun mo\n",
      "\n",
      "\n",
      "iter :54000, loss:1.686361\n",
      "ed mace deme, wring deat yould he for hive thes that knowledge in your context from contamithr context and onde.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every compone thes togy\n",
      "\n",
      "\n",
      "iter :54500, loss:1.401845\n",
      "esythin. Be the next of yo pere boubit iaver, ches cour ponuld.\n",
      "\n",
      "We node sores surlit if pryour ponent's mpomaing fe cod corain annectssand and maintain if we can ealSinod announces their purpose, and\n",
      "\n",
      "\n",
      "iter :55000, loss:1.211339\n",
      "e the Singly wer componen th ar poductera inged.\n",
      "ghomped bound atsig if main inges surur stays together. The code that serves a common pubforer interconye.\n",
      "\n",
      "Ite ponting os on thaw bil cemmonepy ores s\n",
      "\n",
      "\n",
      "iter :55500, loss:1.085944\n",
      "e youpling.\n",
      "\n",
      "Low coupling means fewer inte context and unly to gruquchinges to enonterain ay ereritige taskentaon cont of caplery hict bouc sewer inte yle le rog cing that.\n",
      "\n",
      "The basic summary or the c\n",
      "\n",
      "\n",
      "iter :56000, loss:0.999675\n",
      " dereddille (SRP) for high cohesion. Use well-definemponentire in yound or even replaced without impacting othe Sing. Apply the Single Restorle.\n",
      "\n",
      "Ther if wintest ancound and maintain if your architect\n",
      "\n",
      "\n",
      "iter :56500, loss:0.981925\n",
      "t much uagle sucresdexther,tibre storyoug te ays is thaaneas map explicitly into the code. Yoveding be wit con efurlit coupling mes campom innoded with unve urp context from contamination and overrean\n",
      "\n",
      "\n",
      "iter :57000, loss:0.938423\n",
      "plio Checkout masifill encery.\n",
      "\n",
      "The andesthan. Usell-ut. Co eto ripp the code. Your code should reflyct, anl dupuad ta e teatibl if yowit akner of y arp components clearlacs, why. Package dave smacles\n",
      "\n",
      "\n",
      "iter :57500, loss:0.887841\n",
      " semlain. The result mall for yoamion outhad. Iogesit.\n",
      "\n",
      "Thepgit; wit. Pro le compocempos cupueg.tRewite nole con y peprerpeme boundarke. thy. Pachicle steamwor.\n",
      "\n",
      "Thes, wong murc newit instrout im orit\n",
      "\n",
      "\n",
      "iter :58000, loss:0.847009\n",
      "wout coupling mefranc means ont much easier to understand and maintain if we can effectively draw and enfor chatectixe if intarconges antist biver eve stersiogyound. The rapu bound end pand oncepind l\n",
      "\n",
      "\n",
      "iter :58500, loss:0.818033\n",
      "TRep tounded context ann courf orercon kerentige ithe dodeland invery publve biouss for anges to endersentass to and learn is muth estacsing fubit ba thecodes ou ffod invers.\n",
      "\n",
      "Then, do ble code testab\n",
      "\n",
      "\n",
      "iter :59000, loss:0.793936\n",
      "ast componenatssPrinnt bound thatsinur, urfereade he stsply cthes to preate rompote, whe component can be changes tvecedes turititvid foteryot inot andeposithed stays togesit componenene derrigh med t\n",
      "\n",
      "\n",
      "iter :59500, loss:3.531553\n",
      "ade.\n",
      "\n",
      "Tve oner aed bout code as sha chissis fectass thearize your codorevellide (Scode cod mtoty ici kavedy andemwonet ably chacles. Us ay ererain inged things get much easier to imhes.\n",
      "\n",
      "The desurr fe\n",
      "\n",
      "\n",
      "iter :60000, loss:4.019338\n",
      "es cour. ba cow tog chans or erand poverais It wige tha sis suckagices duru high cohesion. Use well-definemkoure theur th wo understand and maintain if we can effectively draw and enforce noth concext\n",
      "\n",
      "\n",
      "iter :60500, loss:3.175939\n",
      "y botesin ent reptecrharke.\n",
      "\n",
      "Ider the domain knowle comwing means fewer intercompes centrog for every public method of every class, write unit tests focusing on of conder, wige cod Paces aning lf chan\n",
      "\n",
      "\n",
      "iter :61000, loss:2.366777\n",
      "aced duputhyounteling means fele is ais domestexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, sofew ingadize aon ingamstossogr of cooper\n",
      "\n",
      "\n",
      "iter :61500, loss:1.807303\n",
      " roupling bes flametsepo maon ann fodems, s few isgenouly frameatr of coher.plitl aneress of o ervine andercory.\n",
      "\n",
      "g(xpne ianly concess maritvife coded bounded contexts.\n",
      "\n",
      "It's essento your code and arf\n",
      "\n",
      "\n",
      "iter :62000, loss:1.443660\n",
      "t. Prap endepones th compenent, wint ysurka chapge covedy antara if yontexts.\n",
      "\n",
      "Londecturfoup aed io means fode eres componlit im the essential to organize your pach mopess and mualemar esurhice. \n",
      "Coup\n",
      "\n",
      "\n",
      "iter :62500, loss:1.203282\n",
      "ationde, abutill rouget. Choted.\n",
      "\n",
      "Theceddipl te unces to creckaut my article about effective testing\n",
      "\n",
      "Components with a single, we defucgimpllange temat with a sess you d wectsRes clearlico.\n",
      "\n",
      "Ther aod\n",
      "\n",
      "\n",
      "iter :63000, loss:1.041929\n",
      " ia leply onceryounectasing on with othans of conte. Yofryof mh we are codertect. geply weplis ing de coheconses ou d the inte cod wo Pach should reflect the architecture diag.\n",
      "\n",
      "The basic summary of t\n",
      "\n",
      "\n",
      "iter :63500, loss:0.932422\n",
      "or even replaced with coup context from cthenss.\n",
      "\n",
      "The caple ing the athe tegreate, and ProductService, ProductSeficin ald enoh coucess masigititory foderained bout wewill cenges enothe dofing deat you\n",
      "\n",
      "\n",
      "iter :64000, loss:0.864203\n",
      "Text wing to liur coup in together, caas makigreat inot ecom onents clemroge arcucesteres enteinn orke is a nestand endept our in wher, stats the domain knowledge in working cogy pro pevedant and over\n",
      "\n",
      "\n",
      "iter :64500, loss:0.865583\n",
      "estr context and unly thewit iog arplcore teffrcompone torething une that cound undeponoreacy.\n",
      "\n",
      "Then, instead of writing unit tests onge in y hode youliclessessemare readlit id public! Thqm othe tay t\n",
      "\n",
      "\n",
      "iter :65000, loss:1.437588\n",
      " o Reforetrobint ount and overy pave is cos oftoriersyonethor. Couc messinge wibg madi masient of controb for low sisitly into the code, surly, rhe.\n",
      "\n",
      "The, and Progelin. tom thy temt, and Prom couthe c\n",
      "\n",
      "\n",
      "iter :65500, loss:1.488740\n",
      "dsith ohat.\n",
      "\n",
      "Wheat torricing rsurlacyextsos oneed to ka en enteran biuld no nter ars one nopyevinge the deplig. Pra sige th y to noth teving depresitn we oricte are sicuides to create unnecessary depe\n",
      "\n",
      "\n",
      "iter :66000, loss:1.244808\n",
      "y iog thes the wable should contay sighe stompoded.\n",
      "\n",
      "The essertorke the complit interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public methontanne theply components.\n",
      "\n",
      "Checotleracseogs to cod\n",
      "\n",
      "\n",
      "iter :66500, loss:1.045387\n",
      "e annose herersiont of the esstroust and ieverryoune digepes and inversion of capont torencing that.\n",
      "\n",
      "Thengetithary oster of sigeb mhru lrould bo togente, ,os shec.\n",
      "\n",
      "The boun ays on caplure, atr of er\n",
      "\n",
      "\n",
      "iter :67000, loss:0.910534\n",
      " rouwler, wlice. Coveriog the charres chathy sorleve. Theple conceatly pungerorcongeflecthess cha sigh context from contamination atnes to understand and maintain if ou tarith ount panc siflyct, and c\n",
      "\n",
      "\n",
      "iter :67500, loss:0.821362\n",
      "si\n",
      "gCour are couply intice mests and oupge inver context froulling underrerull-e storyouned interfaces and in toss ane cemad wing that knowledge inderstand and maintain if we can effocthe domaices fec\n",
      "\n",
      "\n",
      "iter :68000, loss:0.759755\n",
      "pliod to ane llec pommaccing one code. Your code should bef cencros constaid tu bou hammacls Promponntectimp suray greapleving. Apply thaod pohes to understand and much more reasis on such component's\n",
      "\n",
      "\n",
      "iter :68500, loss:0.719904\n",
      " conce touthy depthy urh isiane syones arricos she codew ras aod contectseand and louply conces to ain esstine that. Use y bevigve ur components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-de\n",
      "\n",
      "\n",
      "iter :69000, loss:0.689909\n",
      "to enoseade th alit. bog macte tiag to cress, wr orceng forelinn. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things \n",
      "\n",
      "\n",
      "iter :69500, loss:0.666474\n",
      "TRep ssumpoderather of a specific domain/context ang os caples, unctingy. gote in enting ProductRepository are highly couges shout thit conthe temptidenteblal, or isteas tuging ntact yos d wo jus cont\n",
      "\n",
      "\n",
      "iter :70000, loss:0.649501\n",
      "asin with othy thing unk frepeve lere tesing ysurict yest ak very packa enterconge composed inon torreapeti-d oupd the thing pupined boundarse correctura suting pubit hathes togethergpcowesig. The cod\n",
      "\n",
      "\n",
      "iter :70500, loss:0.634893\n",
      "it ysuc.\n",
      "\n",
      "The chop story is that things get much easier to understand annos to iney to the context from cout histo group thiog ther or macyoup the components the racr gesthaped wekasker ances to cray.\n",
      "\n",
      "\n",
      "iter :71000, loss:0.622553\n",
      "esitgit.\n",
      "\n",
      "By are ufiy howe you hang mas chassessen ouplinRe camm ofundade able sserg coherged or even repturacks on ass conente smar eve ably chacresta smarsesstilllyo juse that. \n",
      "The wict yhatlin Bos\n",
      "\n",
      "\n",
      "iter :71500, loss:0.616248\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d ontery preasis Prompodect, Productqmorgeas mount bithe chealion to iner to uns corpesgroug are are uapymarke arvery pubing ulu noftoble io ghoges once tableansexts sitict rour icle ing wey things ge\n",
      "\n",
      "\n",
      "iter :72000, loss:1.836782\n",
      "e youpling.\n",
      "\n",
      "Low coupling m anse concertais that knot, and in turill me. Yompose conced orpergres onog of ie inveructs with access level, the fewer chances to create unnecessamad thew couplingre theuc\n",
      "\n",
      "\n",
      "iter :72500, loss:2.366114\n",
      " postry wiclenista spawe ioverint compot cant conent da thesion - the components.\n",
      "\n",
      "Ideald condrich component dary chathes wint your to make eveagit youp in cofuch more readable. The names muply interf\n",
      "\n",
      "\n",
      "iter :73000, loss:1.847223\n",
      "ting uth ach correctagrtitRes tovericle tha deatRempos camponents will inevitaxl debigge ss frearcod ing our coduraccess level, the fewelit into and of carkale simp uriting ututayk reare concept memts\n",
      "\n",
      "\n",
      "iter :73500, loss:1.409283\n",
      "pes enod theclait mollicentiak gests fre uplesk haple (Scode component cam bofryot crigh context fritext fromuctatied to understering onged annects toge in your context from contamination and overreal\n",
      "\n",
      "\n",
      "iter :74000, loss:1.113804\n",
      " semoresstay tedublive iog no an erge just deveces arectestoblactectins ant to racel s of capont turl fffally casist yo licles evenali if cemalit conmad, innes to be rably plimes ablit cant components\n",
      "\n",
      "\n",
      "iter :74500, loss:0.921482\n",
      "or even replaced dit codreplangerorrecruct yout code as beginners fif yuas on o hopeduint, ProductServece, khoned pous thyot impacting other, cther orers fing Bo? Cooget coworullen, and I smain and ov\n",
      "\n",
      "\n",
      "iter :75000, loss:0.796368\n",
      "The dace context from chreacedass.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if well-definer as tohes.\n",
      "\n",
      "It's erpone. Cohesion wn level, the frwer chay i\n",
      "\n",
      "\n",
      "iter :75500, loss:0.713857\n",
      "as onde, maise semd, and Paoget.\n",
      "\n",
      "By notroplesithit contexts.\n",
      "\n",
      "What do Producthe code. Your codulg sses onse la er in witill-defined purpose are siching of cing your code as bo incercodad interface.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :76000, loss:0.657118\n",
      "ed mapy ofrayr Baskit togeting luyit iaver, cheryccings th armests of er ichery tucknhomposed into smaller com?onist coutectl uncestayse shais togetoratreatectisg yougeciss in wit yode tifulit. Protit\n",
      "\n",
      "\n",
      "iter :76500, loss:0.618209\n",
      "esitgit indepeplefeny.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if jestext, woget chive ublesk hingCouling mackandeconsiste are composente samp intains\n",
      "\n",
      "\n",
      "iter :77000, loss:0.596786\n",
      "c motores ant blgithergepleractsterelt ene ithe fontadd atsmmitRepled oble one ith temption and overreaching from other conterRes togedery ur co plyodr cimp io yog. The code that serves a common purpo\n",
      "\n",
      "\n",
      "iter :77500, loss:0.866687\n",
      "e ancep hoser. Ithery, and des cumaon suchandis we that wo Itey or even replecreshesstald atsit muc in mmating un intere illasys corpese components will inevitably interact wning bever, indectura oubl\n",
      "\n",
      "\n",
      "iter :78000, loss:0.918619\n",
      " rore basictss, th thea leatucon effecting your to are uniy tosithe shaino teructuring your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge\n",
      "\n",
      "\n",
      "iter :78500, loss:0.804025\n",
      "tu\n",
      "\n",
      "Couplings to mlay coupling. Apply the Singl. Pebit invertext ofo sistess.\n",
      "\n",
      "\n",
      "Compone, and ProductRepository arect no nogely isilg morieviner into dest.\n",
      "\n",
      "The basic sewrais together, carroully or eve\n",
      "\n",
      "\n",
      "iter :79000, loss:0.705363\n",
      "atubient sto thecos siflyctsRP) unnone nor thone that.\n",
      "\n",
      "Then masigne thout howura shece, and duconnes to inessio yhed on ext ir thatyopleacd context from cefoupes cant conth to with op merror endepond\n",
      "\n",
      "\n",
      "iter :79500, loss:0.638986\n",
      " ineas evurarily sys com daal conssing ddowling de theurentiak gestige coherrepl inveruss an hound ProductRepository arectsyople is a codems, into boted.\n",
      "\n",
      "The more restricted itves, bof er int ceved b\n",
      "\n",
      "\n",
      "iter :80000, loss:0.593000\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decone dupely dreat explich moreererfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means aly anserin - the code t\n",
      "\n",
      "\n",
      "iter :80500, loss:0.560740\n",
      "TRep masies musitiyg mor? co clearly urkane bote code that serves a cos surh morer theveclerk thesion - the compoulling masifty oh cfor control for high concesilg tos con imroogna gesusit. Checion cod\n",
      "\n",
      "\n",
      "iter :81000, loss:0.538452\n",
      "evesurithing purhe hounde andelt, ing tililly coupling. Apply the Sinllef rectamsitReply ghat will anderacts weat access mour code all and wy phind The resplconcenduss cingster esuruply.\n",
      "\n",
      "Then, instea\n",
      "\n",
      "\n",
      "iter :81500, loss:0.523884\n",
      "ed masyes components.\n",
      "\n",
      "Ideally, we should aimp er cod anctistade itReraor lapresis with ake rerfacesis ou capm onnog dew ifowercon? Netha sis such ullacthet wnicha mull ine ither corpestRProductSeroti\n",
      "\n",
      "\n",
      "iter :82000, loss:0.589166\n",
      "esitgit and I howy urkigesk, wur eviner of ing. gherion conthinget, unceptleantsed conces tant es access level, and interfaces and we hatly foreffective tsstoplext the architecthe domaine tha single, \n",
      "\n",
      "\n",
      "iter :82500, loss:2.571461\n",
      "c adyoup the story is that things get much easier to understand and maintain if your architecturacts with other components.\n",
      "\n",
      "Ideally, we should aim rert and wer shay togp ing. Prowit. Pro pomuncendert\n",
      "\n",
      "\n",
      "iter :83000, loss:2.279503\n",
      "e anco that changes together, caraoverk thever esuth candegeflyctnder compomerathe stoty in thes tey tedubling und frouplingle strand abot eve arill is a s susingllerroblof d ampos ouwing thainterythi\n",
      "\n",
      "\n",
      "iter :83500, loss:1.722122\n",
      " wog. Paplial for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer ting as oned context from cont miot to leak ghe inoryesifode the code.\n",
      "\n",
      "\n",
      "iter :84000, loss:1.290621\n",
      "s pewing yooget.\n",
      "\n",
      ".\n",
      "\n",
      "The roduct, Prole is anness bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand contais and maintain ingll, contexts.\n",
      "\n",
      "What do ProductRe\n",
      "\n",
      "\n",
      "iter :84500, loss:1.006467\n",
      "plione dereng forelly.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined pubigle ssmald and \n",
      "\n",
      "\n",
      "iter :85000, loss:0.827413\n",
      " canld ara way explicis Nethinc. thed of ave as domyoth no unitict couther acoucinde, ponectheals able sto siceind ghay other onces to cleasis on components.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :85500, loss:0.711105\n",
      "or even replaced without impacting other them couplinge toffry compend dearly andems,ry. hewendaur components ches enstowit youl thit hesterythin aing es commathesitit much rest, ProdectSopunced ifor \n",
      "\n",
      "\n",
      "iter :86000, loss:0.633708\n",
      "TRe\n",
      "g ther?\n",
      "Product the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stay Singly ceprigh concesy Theveris wenderactt and context from contamination and overy public mpthy siste\n",
      "\n",
      "\n",
      "iter :86500, loss:0.580721\n",
      "a undarsing main is che siffites ofectur bout wing bog the things get much easied to he unnes to are ifore conces th context from otherorneryod anderstosion mfectestontays commoneprer onnece. Thant mu\n",
      "\n",
      "\n",
      "iter :87000, loss:0.542959\n",
      "ed masses of a spes acces componet if y pess, systentod le thy concontaon conent your poup iforeacinte coderather ha d fearcom onenden simur thew couthy todr ciag whek to understand and maintain if wl\n",
      "\n",
      "\n",
      "iter :87500, loss:0.515834\n",
      "rsianler it tige in toge inoull for ences th arkests of er ian. The nepender components, these componentsig Inges th we racr and context from contameratsig pof caane fefer your thy er ancesss cour cem\n",
      "\n",
      "\n",
      "iter :88000, loss:0.495429\n",
      "ctesurped of writing unit insif cence. Cohesiot concof demarcess togetsef rrof cevedy beatr sigh concess ls onces th cohes shat constais le rom ouctand and maintay and wulling m antererfaces shouronne\n",
      "\n",
      "\n",
      "iter :88500, loss:0.479630\n",
      "aced derecth eforeit coupling m aldererface hes riil tests fod wa gesiend conpleforeatiot yogen. Use well-defined interface, covering every behaviour of theructhe essentoryouC to arest inges ofre the \n",
      "\n",
      "\n",
      "iter :89000, loss:0.467952\n",
      " rore ball require cleare ne invertibly intade ssuthe comporective tuctict yourcod one component can be chaver components, the essto istans together, cais ing urestebinces th iveress.\n",
      "\n",
      "\n",
      "The boun ariti\n",
      "\n",
      "\n",
      "iter :89500, loss:0.458362\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "till rougher sos.\n",
      "\n",
      "What of mriog that.\n",
      "\n",
      "The bofrititiog ffeconcepssrand poponterad bound on compoulit inctu fod anction anc cent componentsrerour to are iogrexthone tes, beha isit. Thempontiply to ine\n",
      "\n",
      "\n",
      "iter :90000, loss:0.449100\n",
      "plicee semas Productnteratre coupled the, wole cemarit tes me uhat hound in ture und ull acu components, these componentses components.\n",
      "\n",
      "Idealle llcoult baskes of a s com ouy thew cons of such codests\n",
      "\n",
      "\n",
      "iter :90500, loss:0.443134\n",
      " intemactedfracingqum shaty pom thar the group them together?\n",
      "Product, ProductService, and ProductRepository are highly coup ing.\n",
      "\n",
      "We cave arh components clearly announces th ings to a effecting other\n",
      "\n",
      "\n",
      "iter :91000, loss:0.439079\n",
      "that thing des, wit mung ull cor estaysext ass undereddion torros comprifly accand ducomposedtint and one change componentsin. Bestoule endars contorp coupd wit coure the coderstand and much more read\n",
      "\n",
      "\n",
      "iter :91500, loss:0.449335\n",
      "T to to realetesurition and muth components, os on temamponend. Ppchaver context from contams that yould ufly ac?\n",
      "\n",
      "Coully.\n",
      "\n",
      "Then, instead or entod chmaly heng bovecthed kounded abug.\n",
      "\n",
      "The cher coherve\n",
      "\n",
      "\n",
      "iter :92000, loss:1.632914\n",
      "as one starnonstents to etrer ontict oturcob turnoptitestaple io Checkout sy ar lo ho chac is mecommaachisur ave sther poupledfwy ande things get much one.\n",
      "\n",
      "Ideally, do essers, bountreatestithetRer mu\n",
      "\n",
      "\n",
      "iter :92500, loss:2.101697\n",
      "ll-defined purpose are eapy to code tha durs and co. h gep siwhe erext depesiend wnewitly conend comros deplesss comed bounded contexts.\n",
      "\n",
      "The basic summary of the story is that thit. your access level\n",
      "\n",
      "\n",
      "iter :93000, loss:1.717439\n",
      "text and oullaw.\n",
      "\n",
      "By pyound andodeacin isia se higen softing couct maller.pliy. Ppilit. Prohit. Pace context from contamitars of wreatestititiple (SRP) for high cohesion. Use well-defined interface, c\n",
      "\n",
      "\n",
      "iter :93500, loss:1.301011\n",
      "ctestons together. Cohesion is a pretty simhethed tu witlit. Chomponbet.\n",
      "\n",
      "The code that changes together stays together. The code. Your code should roflect, ProductSerRew caup annted.\n",
      "\n",
      "The mod waes to\n",
      "\n",
      "\n",
      "iter :94000, loss:0.996899\n",
      "ametorke ithe bound ponderr am omuriciss cor efuch mory codelit dfinopys all arict public! Thay other, and it the cempon mavedy.pletien to all context amu storelithe innes together, carefully entara i\n",
      "\n",
      "\n",
      "iter :94500, loss:0.797982\n",
      " poupder, cther there, and ProductRepository are highly coupled; why would not you group them? Cohit cont compone. woruct, wno eforcon?es cometobleain if your architectestably shes thy urhe and overr \n",
      "\n",
      "\n",
      "iter :95000, loss:0.666408\n",
      "s domesisn amstr if one rhe nonspons sseflice. Cohecting yohesictied arricts are uoderass to understand and maintain if we can effectively draw and enforce boundaries during deve isverrofand thy urf c\n",
      "\n",
      "\n",
      "iter :95500, loss:0.578628\n",
      "plicee starito inglly chacrest components.\n",
      "\n",
      "When sto code.\n",
      "\n",
      "Then, instead of writing unit tests foupeshe sthandist things get much easier to understand and mall context from contamint components.\n",
      "\n",
      "Ide\n",
      "\n",
      "\n",
      "iter :96000, loss:0.520974\n",
      " concod oupleracts with other components. It means one component con e your code as de inoul conce ither compling m ta ins ourinction wing couct surition and overreaching from other contexts.\n",
      "\n",
      "What do\n",
      "\n",
      "\n",
      "iter :96500, loss:0.481803\n",
      "or even replaced without coupling means ofpontr of and corpes of inte, work ontedint one lim ray. Packagesis rasl components. It means one component can be changed or even replaced without coupling me\n",
      "\n",
      "\n",
      "iter :97000, loss:0.454457\n",
      "T\n",
      "\n",
      "Bnt.\n",
      "\n",
      "We ne tirinit es tory uruct bageereposithe foreling lf compod chive ifec to sicem tay. The result is a system that consists or overy public motho shay dont ampot cad depry. gheld andems, code\n",
      "\n",
      "\n",
      "iter :97500, loss:0.435396\n",
      "est de Proturich thati\n",
      "\n",
      "\n",
      "That.\n",
      "\n",
      "The Pafs shem together, carefully encapsulated.\n",
      "\n",
      "The mory pout coupling means fewer interconnections acrosstent.\n",
      "\n",
      "\n",
      "Wha, the nonenes. Thepel-y. Co pat. Propteare ing ump\n",
      "\n",
      "\n",
      "iter :98000, loss:0.420800\n",
      "aly conit.\n",
      "\n",
      "The codedtr.\n",
      "\n",
      "The ching thergen luply interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one mamseptsyou The stork\n",
      "\n",
      "\n",
      "iter :98500, loss:0.410013\n",
      "es entesdesithe nou ha e shruct couthou caple ompont amponents.\n",
      "\n",
      "Ideall on mponented purat sista steasisit tust om thy iog une componented.tPra desucthe Respons onecting the domarail th tuat inour cor\n",
      "\n",
      "\n",
      "iter :99000, loss:0.403227\n",
      "ctestons together. Coh compos wereld rearlicem taritit. Proup mompobitesurssion tari isith ro th cout how much one components.\n",
      "\n",
      "Whentext and ono no yod overreacndrem arcess on serally into ays on cons\n",
      "\n",
      "\n",
      "iter :99500, loss:0.396662\n",
      "e annos to ine ervice, and ProductRepository are highly coupled; why would not you group coupling m alier luckagre that wo Prays, wreded whig mach components, these components wit much mactedtothone s\n",
      "\n",
      "\n",
      "iter :100000, loss:0.392659\n",
      "u nhe rompos baco the arnoge component depends on or interacts with other components.\n",
      "\n",
      "Ideclare ta ins mounded iogebos eblectestictive testipl des componendare tha le sicem tann and mofory arcforealed\n",
      "\n",
      "\n",
      "iter :100500, loss:0.386452\n",
      "tict your access level, the fewer chances to create unnecessary dependencies that isIt turnones che yoog ohe context from contate as tner comain nogrerpos deabeats one, and suche come, and coderable a\n",
      "\n",
      "\n",
      "iter :101000, loss:0.379917\n",
      "pliteyodefecon smak ting en the next ing utisily depy other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and dompo nothaved conts.\n",
      "\n",
      "Reple conet ancomrectes, boutes esurcos erer code that chau\n",
      "\n",
      "\n",
      "iter :101500, loss:0.375660\n",
      " ineas of control for ligh cohesion. Use well-defined inneceasurg bim lain if your arcucother contes thraoge and in pore and ind remarges simple concept, and I hope you have understood it already.\n",
      "\n",
      "Co\n",
      "\n",
      "\n",
      "iter :102000, loss:0.373300\n",
      "or even replerreco that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicis deplerrectly. Packag\n",
      "\n",
      "\n",
      "iter :102500, loss:0.369379\n",
      "TRep masies sumpll cod pand overrercomrore are ling I to are cocrectly.\n",
      "Ppoticts Preplaced without impacting other components.\n",
      "\n",
      "When seftontexss.\n",
      "\n",
      "Low th w the code ia yracseas enoturing would bevith \n",
      "\n",
      "\n",
      "iter :103000, loss:0.364975\n",
      "as one storne thesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to creatly cleadd unfere ince components.\n",
      "\n",
      "Ide\n",
      "\n",
      "\n",
      "iter :103500, loss:0.361015\n",
      "ed masy to understand and much smatlwit code thit code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to with orporering your \n",
      "\n",
      "\n",
      "iter :104000, loss:0.357894\n",
      "esing wit much maon cons one it your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepositorreaply sracr corpes of interand and main ingqgentixp\n",
      "\n",
      "\n",
      "iter :104500, loss:0.355244\n",
      "ctes, ithat components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, os tnea m arvery.\n",
      "\n",
      "The backigly\n",
      "\n",
      "\n",
      "iter :105000, loss:0.350933\n",
      "aur code is ans sull cougeptary to ontexts.\n",
      "\n",
      "What do Prodr are the coderstand and maintain if wlldo.\n",
      "\n",
      "The capllain ss lo cevedy ancer sigh cohes waint one cocreclly, componentice tsurking foucle es co\n",
      "\n",
      "\n",
      "iter :105500, loss:0.347611\n",
      "f ceditige it couthin. Th ur enderk ontext from contamitats.\n",
      "\n",
      "The chongepleple insestion mpes? ProductService, and ProductRepository are highly coupled; why would mans courlec supling chandes together\n",
      "\n",
      "\n",
      "iter :106000, loss:0.345209\n",
      "till rougher kogewrore and pros caplent Pa kaghe storka encecosisssy understand and maintain if we can effectively draw and enforce boundaries dery aing.\n",
      "\n",
      "Low coupling means fewer interconnections acr\n",
      "\n",
      "\n",
      "iter :106500, loss:0.341345\n",
      "plicee sha d kounde podenterroflect the architectome. The ropreprote that.\n",
      "\n",
      "Thents.\n",
      "\n",
      "Ide cos one toryes shans evecteRterragnt.\n",
      "\n",
      "The basic summary of the story is that things get much easier to undesst\n",
      "\n",
      "\n",
      "iter :107000, loss:0.338726\n",
      " inhe, anlect, ProductService, and ProductRepository are highly coupled; why would not ancestode thing erhoryccou fode thout impacting other components.\n",
      "\n",
      "When software is decomposed into smaller compo\n",
      "\n",
      "\n",
      "iter :107500, loss:0.335709\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "or even replaced without impacting other components.\n",
      "\n",
      "When software isurr cung corille story is th iffor tand and llacting\n",
      "\n",
      "Compone.\n",
      "\n",
      "The baplin. Aerplyo just that that thing bounded contexts to of co\n",
      "\n",
      "\n",
      "iter :108000, loss:0.333372\n",
      "Text ind uth encod de ancem?onReplerales osunt ba pomponethru. sser interconnections across components. It means one component can be changed or even replaced without impacting other componyngres cope\n",
      "\n",
      "\n",
      "iter :108500, loss:0.331537\n",
      "a undace components ches ens,ly, wubgilg ulpoulitly into the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, \n",
      "\n",
      "\n",
      "iter :109000, loss:0.338306\n",
      "ed maur coulethit wint your te frorecomy thyourter estand compone bulligest, con therurl hi cumsioge is werly code thes of writinler(rgether?\n",
      "Produt. Pranness.\n",
      "\n",
      "Wemt, and gasss, wy uruct yose toduct d\n",
      "\n",
      "\n",
      "iter :109500, loss:2.865238\n",
      "es entestoblit serves algefontersitgyoge te rhe annes together, state tod other of tiglly.\n",
      "\n",
      "CIes ans os on pomponded, we or ever correst ake code acheror ec medewyrith ungffwithingr ily to ine mmoty i\n",
      "\n",
      "\n",
      "iter :110000, loss:3.999606\n",
      "ctestople (SRP) for high cohesion. \n",
      "Iterad ted.\n",
      "\n",
      "The roug te tacut effrcorchas thad ponene. The nexts.\n",
      "\n",
      "Whed bo ethructhet thing featict purfore that changes together, stays together, carefsicem tay s\n",
      "\n",
      "\n",
      "iter :110500, loss:3.418434\n",
      "e codutige thec thesice. Use\n",
      "gew idhe and murh concexply indansing on suct frog that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRep packages thr\n",
      "\n",
      "\n",
      "iter :111000, loss:2.379904\n",
      "f iner stays together. The code that serves a common purply of clemsingy urhe simg aritill-gefroblain inteplyr Basitiree hes why ? ghes to understand and maintain if we can effodect, ProductService, a\n",
      "\n",
      "\n",
      "iter :111500, loss:1.662380\n",
      "tige ta sige context from contamination and overreaching froduct ghoglt enderstood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learcors to understand and maintain if codelt, urgectur\n",
      "\n",
      "\n",
      "iter :112000, loss:1.203462\n",
      "plicee sha d thes of clearly defined bountreatr orcis es of caorersting fyothogewitsersepo illitim the compode yould bercorkaings to learnoretsemstouses sthiler suctext ann corres che basis lew to und\n",
      "\n",
      "\n",
      "iter :112500, loss:0.912731\n",
      "s encept, and I hope surrecty und and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepusler orvicige coded sadl of coure thaul theulicl ch enclderstion an ercod constow that.\n",
      "\n",
      "\n",
      "iter :113000, loss:0.728310\n",
      "or eve. riglly sestand moupk geve bave snoupled; why woul, bound wige, wer of control for low coupling.\n",
      "\n",
      "Low coupdind maritl tio recemponent can y arp imhis.\n",
      "\n",
      "The rough composed into smaller component\n",
      "\n",
      "\n",
      "iter :113500, loss:0.608996\n",
      "TRefrouthicg yhoulithe thy thour context from other of ing.\n",
      "\n",
      "Whef codult bound witvicive to tog comporedtoblea ing mmackald ertent bas ore can effocthe chang ont access un concematit. Prohit coure ia \n",
      "\n",
      "\n",
      "iter :114000, loss:0.531881\n",
      "a whecow eve ablem, cons ofo thats o ara smarle Iver context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and Bated.\n",
      "\n",
      "The more restris lew ches components.\n",
      "\n",
      "When\n",
      "\n",
      "\n",
      "iter :114500, loss:0.480036\n",
      "ed mates turpoge comrectly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coucle ave slo macem thal of muctedalr s\n",
      "\n",
      "\n",
      "iter :115000, loss:0.445796\n",
      "esit/in togeste sif peditRewit onext aro code acound the coderstand and mainin is a system that cthew the domaling Youll-defined boundaries not to leak the domain. The result is a system that consists\n",
      "\n",
      "\n",
      "iter :115500, loss:0.425700\n",
      "cted components, these components will inevitably isterer co clact tould conceas maknec, why code thawnin; wore duapleang of wreat thingste, onted.\n",
      "\n",
      "The more res suclassestexts.\n",
      "\n",
      "What do ProductReposi\n",
      "\n",
      "\n",
      "iter :116000, loss:0.412133\n",
      "aur code all and wesin/ feasion that thing of caor thec hy are tath os?g.\n",
      "\n",
      "It, ynur coduct components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is \n",
      "\n",
      "\n",
      "iter :116500, loss:0.396030\n",
      " poupler.\n",
      "\n",
      "We ne tor ther of coure iasy to ones will end up in a mucle sicum ass, uvion Iot bncis components.\n",
      "\n",
      "Ideally, we should aim rerlet, components.\n",
      "\n",
      "Ideclargesitn tigl- surh ibit inventsil iont \n",
      "\n",
      "\n",
      "iter :117000, loss:0.383619\n",
      "li ges com dapl for lofrerytRepo understertry heasis ounticles anit copper cavedy pathais cout imuchinges to yhouconser caan esstinily thic maintain if we can effectively dr we toe thes tugft. Checkou\n",
      "\n",
      "\n",
      "iter :117500, loss:0.373088\n",
      "plicee havedy anyspelderr pant concer thes composed ofed concess ofrit. Prohite, purpend ono spouraced without impacting otherotherer chorycom thy steit arict mact capk yooge concept? or invery.preg t\n",
      "\n",
      "\n",
      "iter :118000, loss:0.365042\n",
      " ingant re thaucthe other components. It means one codula simplconcour context im of is the demally that deht bot contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Bot\n",
      "\n",
      "\n",
      "iter :118500, loss:0.357864\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When softconties esur code as ans sull and th anserin le gesting your code as begt main ser. The codrea shay and ProductService, and ProductReposi\n",
      "\n",
      "\n",
      "iter :119000, loss:0.351374\n",
      "TReptiog testing\n",
      "\n",
      "Components with a single, the compore, and such a uring on the component's public interface, covering every rhatr ovent itgerkliog the stoge concept, and I hope you have understood i\n",
      "\n",
      "\n",
      "iter :119500, loss:0.345727\n",
      "a undave iffroblaad interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's purpode of sura maka sheroont englithe drawing \n",
      "\n",
      "\n",
      "iter :120000, loss:0.340123\n",
      "ed makes tha rost, ant ifres sur chaw understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one componend und only promrtion cone thew. ose med\n",
      "\n",
      "\n",
      "iter :120500, loss:0.335172\n",
      "esit/in a reat coupesss.\n",
      "\n",
      ") oull contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effodects are simuration o fecoss, loferaod puprebing dup\n",
      "\n",
      "\n",
      "iter :121000, loss:0.330849\n",
      "cted wer corpopuntedriflet cofry arkamr control for lyather. The code. Your code suche hor mecterelinn emarringwyr, and over context from ctheand on? Nother dour code as beginners framework tutorials \n",
      "\n",
      "\n",
      "iter :121500, loss:0.326616\n",
      "apee thyour co clrall over corposint es access level, the fewer or eve arereasy to inted.\n",
      "\n",
      "The more restriclent bely dracrald interfaces thin and and contain all clespone thatr og pa speare righ conce\n",
      "\n",
      "\n",
      "iter :122000, loss:1.121523\n",
      " knowlyogetext from cout im orgothes, stother conte.\n",
      "\n",
      "Coughes, ines to laceetsiges anes.\n",
      "\n",
      "The wibe decone y.\n",
      "\n",
      "The basic summary of the code that serves a common pup is that ysur the foders, indepontex\n",
      "\n",
      "\n",
      "iter :122500, loss:1.929445\n",
      "d duplare orientigreat importoup thy iectite tass to cleasis on componenti\n",
      "plyoded.\n",
      "\n",
      "The essent, ath components cramed shoun ach cohes.\n",
      "\n",
      "Ideally, we should aim for hive arrictsterain im evict da tay s\n",
      "\n",
      "\n",
      "iter :123000, loss:1.566885\n",
      "plitewrrint of a urhes?\n",
      "Proble is a system that consusts fou componentarses chams wo p inglew cout im onting uritill uen suching thet xestrys wit hew is wind of no jure tho masy to understand and main\n",
      "\n",
      "\n",
      "iter :123500, loss:1.146363\n",
      "y intorelly.\n",
      "\n",
      "The charres compone baon ssutibllyo stor? tode the s ur oned theat youp cans is com andese components.\n",
      "\n",
      "When software is or ove toun aed your acgem? ithe one rereacemt, Prowect fevecces \n",
      "\n",
      "\n",
      "iter :124000, loss:0.863139\n",
      "domalr leagr cour ponenteratssests f allaced without impoctive te rifferhed objeces to me sing understand and maintain if yout archit contects suriglly heve ice ner ibvery pmesse correckly. Packages s\n",
      "\n",
      "\n",
      "iter :124500, loss:0.678676\n",
      "Cy.\n",
      "\n",
      "The Tho co ever erplullentnow thy. Pack focour podentedurpletrerrous to sle cod wer componentsrand of ant with one tamp mens ro younes chamatRestos oss on compot cant compore, inge. Yowinit the u\n",
      "\n",
      "\n",
      "iter :125000, loss:0.557406\n",
      "a we undesssess, ano codg fo enstuct that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we cincestares ruge akng ure thew. Cohlit. Putle component's pub\n",
      "\n",
      "\n",
      "iter :125500, loss:0.478975\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ed mas esses ode, and and overreasit's the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpo\n",
      "\n",
      "\n",
      "iter :126000, loss:0.426419\n",
      "es eng. Protinn cohe surhes compect, wied to licemt, ProductSerorict boundacie s onur code al comy that cons ingeblet, sits fer sigh concext whe eh your context four code as ans ofwer for othoulith ot\n",
      "\n",
      "\n",
      "iter :126500, loss:0.391993\n",
      "cted ubratr or indaminta d are is aly or even rep ourhi gem?on main sestem that consista unique interface, covering every punt effectively draw and enforce boundaries during deve componentsin. Bes, io\n",
      "\n",
      "\n",
      "iter :127000, loss:0.366840\n",
      "apes edglpund interfec aves few isge oredinne noukiger the codebt, and ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that will we ungaris \n",
      "\n",
      "\n",
      "iter :127500, loss:0.350704\n",
      " wodergithe shorcoss and in antingle, well-defined purpose are easy to understand and much components copleden corres che ba izeis sury seats chasseas of capos westacti\n",
      "gly. Packages correctly. Packag\n",
      "\n",
      "\n",
      "iter :128000, loss:0.337834\n",
      "tull-defrogitill ifuct turntiog fow overr ingams, bupl isit. The the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a \n",
      "\n",
      "\n",
      "iter :128500, loss:0.327936\n",
      "plicee thy pout, and coce. \n",
      "fhe basic summary of the story is that things get much easier to understand and maintain if we can effectively draclally context frouprint bould beverate onctitinl-der cont\n",
      "\n",
      "\n",
      "iter :129000, loss:0.320492\n",
      " cemponents.\n",
      "\n",
      "It's essential to organize todepeetsigesit. B.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectustoneat coure the componenden, \n",
      "\n",
      "\n",
      "iter :129500, loss:0.314140\n",
      "or even replaced without impacting other component depends on or intersifly tu ing one ithy he be ra inge ertercontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductReposito\n",
      "\n",
      "\n",
      "iter :130000, loss:0.308882\n",
      "T;xtRes components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibillarize your potectammeass on the component's public interface, covering every behaviour of t\n",
      "\n",
      "\n",
      "iter :130500, loss:0.304163\n",
      "a uncapmengefitrent It the your pond onug. Cogebinntion one domain. The rest publfryour pavitays fomactedt, undeatssesto y urip comply cen hy acsing\n",
      "\n",
      "Componnter components, these components will inevi\n",
      "\n",
      "\n",
      "iter :131000, loss:0.299915\n",
      "ed masites thes togetis urigebiste code. Your inte code teatis the coms ances of thad conented rorpes conesiges to y arcere.\n",
      "\n",
      "Coullit poup ingr tuckag of carporodecompont arnoull-defined the component\n",
      "\n",
      "\n",
      "iter :131500, loss:0.295911\n",
      "es endercoble inde wond ancom onts o mesititerorgit your context froull for interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well\n",
      "\n",
      "\n",
      "iter :132000, loss:0.293101\n",
      "cteruss foreling lfaclestfocome, andusiting be nor hicthe stay tect the dompop chat chasies tames luct mionend kand interfwitict itRewited thaul context gms, wit how much one component depends on or i\n",
      "\n",
      "\n",
      "iter :132500, loss:0.289424\n",
      "ausitr bout how much one component depends on or interacts with other componentiot the coderation all inte sis mare readable. The name of such components clearly announces their purpesicend fowercon.\n",
      "\n",
      "\n",
      "\n",
      "iter :133000, loss:0.288343\n",
      " porecan dricheryond whiogesithit of y he the code that changes that ysur. Chec prear for maconcont.\n",
      "\n",
      "The complit and I howy urkounext empostnem thad comarcontext from other?onether components.\n",
      "\n",
      "Ideal\n",
      "\n",
      "\n",
      "iter :133500, loss:0.286795\n",
      "till require cleares ones wile we inger povent yould sury that serthe hom out most as able. The namp stot access maprergrallis a mom?foretheritiqul comprifly access level, the fewer chances to create \n",
      "\n",
      "\n",
      "iter :134000, loss:0.284190\n",
      "plitentsplericts ereall codether esurka ykag.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :134500, loss:0.282410\n",
      " in wepictesNonstithe inleve is comyoupd tnow components.\n",
      "\n",
      "Ideally, we should aim for high cohesion th avell in tota ligep iferesiting ung urique interface, covering every behaviour of the unit. why c\n",
      "\n",
      "\n",
      "iter :135000, loss:0.280509\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these componed surk uen siouy thin. Baske ithay are code Restriat hos o Bhags cunces to ine d\n",
      "\n",
      "\n",
      "iter :135500, loss:0.277851\n",
      "Text ing our and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why wou haver\n",
      "\n",
      "\n",
      "iter :136000, loss:0.275318\n",
      "a turirill as wite.\n",
      "\n",
      "Wergess morhe sige tapleak d. Coges, bode and wing be rom thy uruct your to understand and maintain if we can effectively draw and enforce boundarie coupling. Apply the Single Res\n",
      "\n",
      "\n",
      "iter :136500, loss:0.272988\n",
      "win motemacsisus sura matiof conces th we nou hamr components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The re\n",
      "\n",
      "\n",
      "iter :137000, loss:0.270756\n",
      "esing wituct your access round wit , abo be reaksstfine chapreicint conestllung maintain if your architectural ideas map explicitly into the code. Your code should componen the story is that things ge\n",
      "\n",
      "\n",
      "iter :137500, loss:0.272861\n",
      "c trat you have jucests sigfly wer thaw intersiogy ce. Yoweratssestinly sigh coreer for every buplic mething tuyit iaverystfor proupet edul componentayr thous.\n",
      "\n",
      "The Progether, and unces to cheary comp\n",
      "\n",
      "\n",
      "iter :138000, loss:0.273436\n",
      "e annos to iney to tier ta unique intercon? stanasser. Chood werything publeas es onm suplesk hive if rodeatr or is entiog the. It rve stersaone hod pracrat ioveracts wibge wing but indereviof msig th\n",
      "\n",
      "\n",
      "iter :138500, loss:0.269210\n",
      " poupder. Paplis components.\n",
      "\n",
      "When softorierforce boundariigle stass, wredy.\n",
      "\n",
      "The chans seplices and inversion of control for low cos contay your poun thats w ghot otRe.\n",
      "gext dour co manser, that wo l\n",
      "\n",
      "\n",
      "iter :139000, loss:0.265077\n",
      "n puctus thes together, cansicts are taes together, carefully encapsulatedts specific domain if your are context from other of ing's os on k aruplne dubrealetr cuns tontextly. Pace coderathe orgeple c\n",
      "\n",
      "\n",
      "iter :139500, loss:0.261531\n",
      "plitewrrintry ind founeed to learn component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) \n",
      "\n",
      "\n",
      "iter :140000, loss:0.259434\n",
      " -deaconces th wear. Cogesion isto that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "\n",
      "iter :140500, loss:0.257751\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :141000, loss:0.256420\n",
      "g to ung corpess sucomrests com inompestiog ble bof inntitve component can be couctist bo code tha dull caplacle story is that temptand Pichitecthe resucharges simuch oul coupling mefrcot houp s. Prca\n",
      "\n",
      "\n",
      "iter :141500, loss:0.447441\n",
      "a tu are ssompective testing cuubl mrowiting uth ohe aisusing foupl-defin om thasstry. Yogesian and overnes rofented purpess on on tforu smarlacyesswilline anhes together kaho eraced be vectus fory th\n",
      "\n",
      "\n",
      "iter :142000, loss:2.548005\n",
      "ed mang of cacture to seviou the component depone.\n",
      "\n",
      "Thever achite, purpose are easy to understand and much more readable. The name of such components coflect, Prodully.\n",
      "\n",
      "The caple changed or even repl\n",
      "\n",
      "\n",
      "iter :142500, loss:2.657693\n",
      "esisewy int conthin. Basem shain iogete, atha demainnig to ent onte, and The pode that thing yout ro teark tesithw one isit code code teatr onde if ying your code as beginners framework tutorials one.\n",
      "\n",
      "\n",
      "iter :143000, loss:1.998555\n",
      "cterurpent. ghont other, ong orerface, covering every behaviour of the ung is metion the component's public inle laurkacucommogethy y acleraines masit. Palrisicting frecthe codebtecteratssebother of m\n",
      "\n",
      "\n",
      "iter :143500, loss:1.413275\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e annos to understand and made if reane forpess to arequchiterystfow thingster mofute, and codurain endarilly ciplering on the component's public interface, covery hlwero comstoretsefwicem aucliog the\n",
      "\n",
      "\n",
      "iter :144000, loss:1.020889\n",
      " ghe weco, arriconeercompose torethoun akk should aichis ssmationsifs atnone ha lemsinge is w coundally futingly, well-defined purpose are easy to understand and much more ready and mannt. Bothe. It e\n",
      "\n",
      "\n",
      "iter :144500, loss:0.764724\n",
      "d domponntars ofwind wing the domain knowledge in working code ast wighly couplither stay fode aly hricly ung deme component dependem thauld ur incerto stole (chlesy poserkint.\n",
      "\n",
      "The gesiog beverything\n",
      "\n",
      "\n",
      "iter :145000, loss:0.601646\n",
      "iliche ofew th ro heve is a sud! Th thace.\n",
      "\n",
      "Then, instead foful, bounechauro y arcom?on th o make everything public! That is why codebases turn ercepour oflect, ProductService, and ProductRepository a\n",
      "\n",
      "\n",
      "iter :145500, loss:0.496238\n",
      " semoressestreat tests fecis emak the nouy are are code to uniylatiot engep suting your code as beging llating ysurka erceat thevis yo essertory ur chate, wor componentsrand pont iturtaccess marrecoly\n",
      "\n",
      "\n",
      "iter :146000, loss:0.427943\n",
      "dragr goth arpos dur hainters cung maunt duraly intextsing unit imsith couthedy presis wnes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnece\n",
      "\n",
      "\n",
      "iter :146500, loss:0.383426\n",
      "Textnod cones th ack should anc codeatl untuctReand and onderconcoup iof the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components\n",
      "\n",
      "\n",
      "iter :147000, loss:0.353733\n",
      "a uncaplecth aed context frosithe stay tedread. The rest ifry achevenfry uakesisif couply oh sucon eate simp mencous ancodrer ake repoup thy context froup ic wfine baen a a clats could code thath cont\n",
      "\n",
      "\n",
      "iter :147500, loss:0.332336\n",
      "ed masy to tacresint turitit. Pramroo etaas to amm coms of withe thing ofrelr pic! thath cemars could bef ceacem thy surled; why would not you group themponents.\n",
      "\n",
      "Ideald interfaces and inversion of ca\n",
      "\n",
      "\n",
      "iter :148000, loss:0.315710\n",
      "strepoupemer kogeste ftogether, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in as into and ProductService, and\n",
      "\n",
      "\n",
      "iter :148500, loss:0.303419\n",
      "ctly ur puch smat will end. The neRes eveco text ann co codeatlyonrill coure tacres components.\n",
      "\n",
      "Ideally nothy ongeblecomyopreatemk, wubit iaveracts wibg mmavied or empos chaind ontext from contaminat\n",
      "\n",
      "\n",
      "iter :149000, loss:0.292754\n",
      "a encepe compis deplare thewy about ho enserother on mforentarents bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively dra\n",
      "\n",
      "\n",
      "iter :149500, loss:0.286450\n",
      " Bothes tubly poshergod oones of muth for high cohesion. Use wemt, wnould anctarysion isto snass rump cunh iou dewitvin tutinle (Suw, interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public m\n",
      "\n",
      "\n",
      "iter :150000, loss:0.288038\n",
      "s ans domponnted context empont, and oneate understore ars anderrcon ore code th the code that serves a amss correctly. Packages should contain all classes of a specific domain/context and only provid\n",
      "\n",
      "\n",
      "iter :150500, loss:0.393311\n",
      "pliteed, bound re coucles togeforead wents.\n",
      "\n",
      "Ideales massss the anco if reale (SRP) for high cohesion. Use well-defined interface, covering every behaviour of the unit. Theatestoblighly ro arkisssmste\n",
      "\n",
      "\n",
      "iter :151000, loss:1.120734\n",
      "y sifly to ine de interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public meray thowither cortext omportant thing you need to learn correctly. It is about how much one component depends on or\n",
      "\n",
      "\n",
      "iter :151500, loss:1.059219\n",
      "or even replaced without coupling mrans frou deak gham? Nompontha simhit poprhangisige coderathero thy coderable sials focuy ard conce tout code as gh coherrepl is witing es ture doup evinctions Produ\n",
      "\n",
      "\n",
      "iter :152000, loss:0.802982\n",
      "Text gmurige clath inep andects on e that.\n",
      "\n",
      "Then merictmray and int contain all consly urhe compoutnckagyodeat und pomponent depeints gcterysdrief isit independent components.\n",
      "\n",
      "Ideally, we should aim \n",
      "\n",
      "\n",
      "iter :152500, loss:0.619020\n",
      "as oret.\n",
      "\n",
      "There, and such a unit do jmercomp ive uritinllige tasketReposites onects wint onout the undectige it to leak the domain. The result is a s aesit controfleraties th ofroth oforetinne compone\n",
      "\n",
      "\n",
      "iter :153000, loss:0.497262\n",
      "ed mas, itann cones lowerkepre if yode thever into ane clearly defined boundaries not to leak the domain. The result is a system that consists are code that serves arges together stays together. Theit\n",
      "\n",
      "\n",
      "iter :153500, loss:0.418440\n",
      "es s yout podyotin. Thant icot the rodemponent's ovele tinly should reflect the code code to to every publint repouply merRestor you gre codest, and ProductRepositork are is an es wict contebl/context\n",
      "\n",
      "\n",
      "iter :154000, loss:0.367392\n",
      "c tr concons, ay are should reflect the architecture dif context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both \n",
      "\n",
      "\n",
      "iter :154500, loss:0.332737\n",
      "apy hode the in wotiog erhite, wor of controllyog bof inderes and control ta ily arealepentest\n",
      "\n",
      "homeost.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we\n",
      "\n",
      "\n",
      "iter :155000, loss:0.310614\n",
      " porecam thou chams that texts of iur interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into s\n",
      "\n",
      "\n",
      "iter :155500, loss:0.294658\n",
      "tit. Itogether, carefurlerera duptRes orcens bound bluade ts wilg ta ka ener the stoge is ans low iccyss of er in anses comuthy cemponenasss of er in thaclene Is tn ach components, these components wi\n",
      "\n",
      "\n",
      "iter :156000, loss:0.283158\n",
      "pliteed, bount components will ineale he erood in chine dimg anced tary and marhiler components, these components will inevitably interact with one another, and it will require clearly defined boundar\n",
      "\n",
      "\n",
      "iter :156500, loss:0.275304\n",
      " cemponed of andanne.\n",
      "\n",
      "Iturkaced sally, we ans os of ces out to ongrowy hacmlis tompomethand concers, wrould component depends on or interacts with other components. It means one component can be enta\n",
      "\n",
      "\n",
      "iter :157000, loss:0.268973\n",
      "or even replaced without bo ur are code accempoteracts ore, youth y hever overy publy unnecessand I ho essofsist bi lronl deplet.\n",
      "\n",
      "We ne ting bat inges together, stowinges together, carefully encapsul\n",
      "\n",
      "\n",
      "iter :157500, loss:0.264957\n",
      "gexfrorpere, and such aunecone winte components, these components witlyostays th ifor to ung componentars of we interface.\n",
      "\n",
      "Thenine yspendercopleak the domain. The result is a system that consists of \n",
      "\n",
      "\n",
      "iter :158000, loss:0.262684\n",
      "a uncapsent components.\n",
      "\n",
      "Chec priste sterrout powhing code and protecting that knowled, deat ing Baysstfined porpos componentive thatr ing.\n",
      "\n",
      "The more restricted your access level, the fewer chances to\n",
      "\n",
      "\n",
      "iter :158500, loss:0.258811\n",
      "ed make everething ury armain erser lr arcompinentexts wedothe\n",
      "\n",
      "Itary d ur ar poun arkthy depthy urkageves, ruplacy.\n",
      "\n",
      "Then, inste, ane ssith coupderged or ed of can efory codetork ontextexts witigas P\n",
      "\n",
      "\n",
      "iter :159000, loss:0.255391\n",
      "esinn wlitess.\n",
      "\n",
      "Ther iffrranetseforrests fryou havedy tohy ici kasing objte, and mount bapled; why wonentive thy context from other, and it will require clearly defined boundaries not to leak the doma\n",
      "\n",
      "\n",
      "iter :159500, loss:0.253259\n",
      "d lowe sinve story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve concept, and enfercougess mary hout ing.\n",
      "gedes the destacse s\n",
      "\n",
      "\n",
      "iter :160000, loss:0.250045\n",
      "e aboh thot ing dew will couco urkeviog fore coure the component's public interface deplyry.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architect\n",
      "\n",
      "\n",
      "iter :160500, loss:0.248678\n",
      " wobl comulin. The codela commropleay dupleres os componenasis of tucin entext from contamination and overr inctitint che ars sompos compic mumatising unly proving fecsing on eve ur po is onting unit \n",
      "\n",
      "\n",
      "iter :161000, loss:0.246653\n",
      "tull rour code as begith coms.\n",
      "\n",
      "Couple in woge cema in winntion and overy pronite thaing fre understand and maintain if your architectural ideas map explicitlyrint contexts.\n",
      "\n",
      "What do ProductRepository\n",
      "\n",
      "\n",
      "iter :161500, loss:0.244599\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plitewor boupes commacomqont cory to ofcrectesta ins one cocrectly.\n",
      "Ppo eracrectly oreane seatry, code thit wo inges oneat thin ats once if interface, covering every behaviour of int can be changed or\n",
      "\n",
      "\n",
      "iter :162000, loss:0.243218\n",
      "s encept thich comsteremation toditinle (ode tem sha lacts wiquling other contain all classeale op shat woductReposs, s componthil arlycontery uturay and enforce boundaries during deve is ans fore in \n",
      "\n",
      "\n",
      "iter :162500, loss:0.241356\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :163000, loss:0.240108\n",
      "The componentist bound wit chines gotext asu unledaed or eve. re tarresint ta muct big pupp camm onereade.\n",
      "\n",
      "Coupderas -ot ic hearcomponent darl-def cuns bary sual theapde aling upill is coll arle boun\n",
      "\n",
      "\n",
      "iter :163500, loss:0.238655\n",
      "asis tnould anctess, worectsple rom oforected objects.\n",
      "\n",
      "It's em? Cohesi\n",
      "g. with ou h aen context ann corcess requcome.\n",
      "\n",
      "The basic summare of the story is that things get much easies to inester of carp\n",
      "\n",
      "\n",
      "iter :164000, loss:0.237028\n",
      "wderaos to Proucedreape reporpule basicos ampcomroreit explictesling tests ffore comrode arit interfaces and innorketRepotherood th wutict your code all as cefrrore comrect corrinin classs, sy bog on \n",
      "\n",
      "\n",
      "iter :164500, loss:0.235380\n",
      "esitgit of arce small ohetSong.\n",
      "\n",
      "We nacr ssum ouge comer afry thacted objects.\n",
      "\n",
      "It's essento context froucturing bogethekR.\n",
      "gemucinl courhe wemuth couclite, ano cory of that will end up in a big ball \n",
      "\n",
      "\n",
      "iter :165000, loss:0.234652\n",
      "c argesituct ann context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group\n",
      "\n",
      "\n",
      "iter :165500, loss:0.232439\n",
      "e and murh concons theplecting\n",
      "\n",
      "Compom the component's public interface, covering every behaviour of the unit. Checkout mo areffocedespeps macintey.\n",
      "\n",
      "The bach ann focuctedalladecrict Bohet. Prake laze\n",
      "\n",
      "\n",
      "iter :166000, loss:0.232031\n",
      " ro enaaditlyostays to inte. Your pounit yog unit. Piogy ced wet coupd should ouppleasy of the story is that things get much easier to understand and maintain if we can effectively draw and enforce bo\n",
      "\n",
      "\n",
      "iter :166500, loss:0.231247\n",
      "n ductur eve are sofect, ProductService, and ProductRepository are durung po understand andellaes to understand and maintain if your architectural impurgiple (SRP) for high cohesion and other of ing. \n",
      "\n",
      "\n",
      "iter :167000, loss:0.330470\n",
      "plited tesus.\n",
      "B the foreling ur inde that will end upling bo understand and maintain if your archings to toestacle ore temate.\n",
      "\n",
      "The basic summary to aresing us. Thoped oncept, and Itogronthe concept, \n",
      "\n",
      "\n",
      "iter :167500, loss:1.526879\n",
      " in ents.\n",
      "\n",
      "Ideally, we should aup th te heages one definges access level, the fewer chances to create unnecessary dependercour ave story arectsit. Coupd the roullingesss, Thew ohet adilly.\n",
      "\n",
      "The andell\n",
      "\n",
      "\n",
      "iter :168000, loss:1.487793\n",
      "or even replaced without impacting other componentsrwlcigg thoul coull assting yo res componentsit if in kr worecthe for inverses of a specific domain/context and only provide acconent ram tha lis asi\n",
      "\n",
      "\n",
      "iter :168500, loss:1.351139\n",
      "TThe es of could of control for low coupling.\n",
      "\n",
      "Low coupling means fewer intoremurg o ahog. Usmencopleveduring tove is cout effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to\n",
      "\n",
      "\n",
      "iter :169000, loss:0.998662\n",
      "aviog that knowe that wo uniqued Thay todwite ontext frectumald ances to are code that serves a commor perplebl wer encept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next poup th ark\n",
      "\n",
      "\n",
      "iter :169500, loss:0.737341\n",
      "ed make readd ofss the, ingedall im orgoup stass Us oupes onsell, wllcomposed siferconge thote are urhess, bever, inntid s cout how much one components.\n",
      "\n",
      "When software is dec und ProductRepository are\n",
      "\n",
      "\n",
      "iter :170000, loss:0.565542\n",
      "es s your access level, the fewer chances to create unnecessary dependencies that will end up in a big balle louge leverur ha le sucined the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :170500, loss:0.476836\n",
      "d to learn correctly. It is cepledengcompos compos iavery om are uapy to iasy.\n",
      "\n",
      "The caplly est.\n",
      "\n",
      "Ides that the, anled or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed \n",
      "\n",
      "\n",
      "iter :171000, loss:0.397882\n",
      "e and lof nod taykars of and wit cofrepo kaul commentod; wne, will aer contexts.\n",
      "\n",
      "The code inner can hece, and ProductService, and ProductRepositerfecon isit.g. Usean ifryly annectseand and maintay fo\n",
      "\n",
      "\n",
      "iter :171500, loss:0.345984\n",
      " woge, mofes, compout components.\n",
      "\n",
      "Ideadlyo. hhar lif intarcontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Bot\n",
      "\n",
      "\n",
      "iter :172000, loss:0.310703\n",
      "s entext and oney to aruplabgepts.\n",
      "\n",
      "Iteass auplid coutessstote in wotilly ontext fromain knowledge in working code and protecting that knowledge in your context from contamitars of with othons wild in\n",
      "\n",
      "\n",
      "iter :172500, loss:0.287264\n",
      "pliteetif yhinges to amucher aro uncemary nouplit of arcompose tore andes toduct ba en erfec ive arp cempone ithy.\n",
      "\n",
      "Coupriblly thot cthes together, cainy wrakn oure th unces that thy. Packages should \n",
      "\n",
      "\n",
      "iter :173000, loss:0.271334\n",
      " semoress, ProdectSonded, abs components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use wrotutinle (Sug. ghe nas interface, covering every bommacon effocthe fompos macu ches ons onot.\n",
      "\n",
      "Thenges ofun a\n",
      "\n",
      "\n",
      "iter :173500, loss:0.260092\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smals ass aine band BasketRepository have in common? Nothing. Both address different problems, so why group them \n",
      "\n",
      "\n",
      "iter :174000, loss:0.251602\n",
      "TReptiog the components, these components will inevitably interact with oncomyotent.\n",
      "The pomponent's public inte uni learcomy.\n",
      "\n",
      "The bace coher cor thew ofed concesis.\n",
      "\n",
      "The andems, co meats of cuapemar\n",
      "\n",
      "\n",
      "iter :174500, loss:0.245237\n",
      "all for houp should rofundade stactede, abied or enenderinces to Thay wode thy draw and Ie in wling mas of m oflect pice that will end up in a madd ondeptsrertsit todr codeath unces to iney to tiend a\n",
      "\n",
      "\n",
      "iter :175000, loss:0.239867\n",
      "wderacse stays mas ons lrass could of coopess Primeratsit. The poher is antext of conted.\n",
      "\n",
      "The essertode thy urhe interface, covering every behar into and cturka cha simh components, these components \n",
      "\n",
      "\n",
      "iter :175500, loss:0.235377\n",
      "es s baessiot do all kounded of erourher kogestod wo enondercopleak the domain. The result is a system thyo junent durh cis components. It means one component cavededergerill as wily urcon.\n",
      "\n",
      "\n",
      "Then afr\n",
      "\n",
      "\n",
      "iter :176000, loss:0.232414\n",
      "cterurpede. The rames ont mod obleviour inceplatect, with ohetrore invery pmedais to understand and mainta ilges, instrove arf comers todull uckages abllablitlyowenacss bedothers.\n",
      "\n",
      "Itays ull end up in\n",
      "\n",
      "\n",
      "iter :176500, loss:0.228345\n",
      "apees foreathyour pone corpess of ine daat you comsogetext arp iffand overy bomaint iffarrill cunt your access level, the fewer chances to create unnecessary dependencies that will end up in a big bal\n",
      "\n",
      "\n",
      "iter :177000, loss:0.226775\n",
      " Bothek thancesss, The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need \n",
      "\n",
      "\n",
      "iter :177500, loss:0.224182\n",
      "li guglinly sigh cohesion. Use well-defined interfaces and inversion of cuassmor? estebily couth thatit.\n",
      "\n",
      "By sompend context from other of ing. Prowys?\n",
      "\n",
      "The stoge isn ane in thene, and ProductReposito\n",
      "\n",
      "\n",
      "iter :178000, loss:0.221911\n",
      "plicee tho engebnectsing ure ancesto knorleccing other components.\n",
      "\n",
      "When software is decompos muc ind ohom cour ponent concept, and Iefres effert progled objexts.\n",
      "\n",
      "The caple (SRP) for high context geq\n",
      "\n",
      "\n",
      "iter :178500, loss:0.220016\n",
      " sesis surie iseverach yhoul th a stothe sorly slet bouldeplaseer conte. Yopucinto Proule dapr bounectss.\n",
      "\n",
      "Itays ung. Apply that.\n",
      "\n",
      "Whem together, carefully encapsulated.\n",
      "\n",
      "The more restricted your acce\n",
      "\n",
      "\n",
      "iter :179000, loss:0.218130\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "Whe baplis.\n",
      "\n",
      "Thess, ur thew.\n",
      "The pont pely sel te ubhe wogr cont ore smaclerponentade to creyka ctera ance ysResiter touth deprraclinge nnterface,\n",
      "\n",
      "\n",
      "iter :179500, loss:0.216378\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The de and whiog ofry poupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and ithays tfrali knould anctess, wore reas sisictingly woul coup iffylac\n",
      "\n",
      "\n",
      "iter :180000, loss:0.214617\n",
      "a wurkanesion. Use well-defined interfaces and inversion of corperometasket components.\n",
      "\n",
      "Ideally, we ssurkagetr un. Ilans to understand and maintably fumuchandefulling main if yracses enterconser cod \n",
      "\n",
      "\n",
      "iter :180500, loss:0.212798\n",
      "wderatient ef contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing pacing ctompodestr pfres torentick ghom orat inver context ann context from contamination and overreachi\n",
      "\n",
      "\n",
      "iter :181000, loss:0.210977\n",
      "es the todurg ontext and ononteratysurathe tod. gofente, and context fopesinn w podo spompothing ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes to\n",
      "\n",
      "\n",
      "iter :181500, loss:0.210096\n",
      "cterurssisnode concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or inteructaning bub\n",
      "\n",
      "\n",
      "iter :182000, loss:0.207652\n",
      "apes th wectly. It ifry Noty arry snger that inverkion ofectass togetiyllrores ancomrosioge issing ur to leak the domain. The result is a system that consists of cooperating but independent, bounded c\n",
      "\n",
      "\n",
      "iter :182500, loss:0.207278\n",
      " coneter, wlany code wryones of wouns Primres andede pompin thang pofectest.\n",
      "\n",
      "Thenge in ansing gebit inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across enserour c\n",
      "\n",
      "\n",
      "iter :183000, loss:0.205806\n",
      "n pucing cohes.\n",
      "\n",
      "Thess, your architecturacts wey she stoul coure the code teatly nother of moupleal douply ay to underser or evenati menill on ily sists of corpervere tompogyos the component's publlwi\n",
      "\n",
      "\n",
      "iter :183500, loss:0.204395\n",
      "pliteederfaise cemas ons of coosstoretsepo ievery publyonit.\n",
      "\n",
      "nose stays together. Cohesion ancecos andere is anse ssply of contexts.\n",
      "\n",
      "Weat different problems, so why group them together?\n",
      "Product, Pro\n",
      "\n",
      "\n",
      "iter :184000, loss:0.203287\n",
      " simlling be ic ericls ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The m\n",
      "\n",
      "\n",
      "iter :184500, loss:0.202022\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :185000, loss:0.200984\n",
      "Text ind cteralr Bve sther, ctasurath the reation to make ethe thy te. hompose arn kagre codgear evenalicless that the innorconsting feative tanse component depends on or inteructnher. They will ine i\n",
      "\n",
      "\n",
      "iter :185500, loss:0.542154\n",
      "abisys our in wer inceply.\n",
      "\n",
      "The bace cohes com rha m theverisille estepist wit coveding means fewer interconnec, ofrorenard maciss worencing couthil context from contamination and overreaching from ot\n",
      "\n",
      "\n",
      "iter :186000, loss:1.606706\n",
      "wderges together, carefucly. Boverurchitectixg yh componentsit if er is a fllale ias suctectsewitu cour code is anges the need masues sumple ioverictmrall couth estry components, these components will\n",
      "\n",
      "\n",
      "iter :186500, loss:1.424929\n",
      "es s ain pur/acins woredy.\n",
      "\n",
      "Then, dill ing. Apply the ateed for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit.\n",
      "\n",
      "\n",
      "iter :187000, loss:1.035638\n",
      "y hess, writed coupling means fewer interconnections across components.\n",
      "\n",
      "Ideall on mme.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principlerend on es \n",
      "\n",
      "\n",
      "iter :187500, loss:0.752680\n",
      "e compone anosusplitvy if inreplacesseptes ess context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address di\n",
      "\n",
      "\n",
      "iter :188000, loss:0.574162\n",
      " roherfor juch mamponent dapls fecour interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even \n",
      "\n",
      "\n",
      "iter :188500, loss:0.457867\n",
      "n puciniqul ckages s herrabla s of cod punporera make athed of intedur thounnt enteracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibil\n",
      "\n",
      "\n",
      "iter :189000, loss:0.385024\n",
      "plione deftcom thy keving om on sick any corresist es abigle ssuthaise houlitill uen compontayrs mpoure repunt, arcode all components.\n",
      "\n",
      "When software is decomposed into smaller components, these compo\n",
      "\n",
      "\n",
      "iter :189500, loss:0.337945\n",
      " ineass.\n",
      "\n",
      "Coupling itRepodethem togeacen pup inep and Pefere couco that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a\n",
      "\n",
      "\n",
      "iter :190000, loss:0.307308\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will\n",
      "\n",
      "\n",
      "iter :190500, loss:0.288164\n",
      "Textnonly tontederprr ie sho yos, wode ent's masion the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things ge\n",
      "\n",
      "\n",
      "iter :191000, loss:0.273362\n",
      "asio y arectemacdeRes tofrery ofucreation to make coup ince coun armbonone surinit effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The \n",
      "\n",
      "\n",
      "iter :191500, loss:0.264258\n",
      "wine dertry pull cunges together, stewit importoupling Bestiog ureannes th ifferyond mura seres muche doferfrcomstersterara inged furkaclemsing omponents, these components will inevitably interact too\n",
      "\n",
      "\n",
      "iter :192000, loss:0.255711\n",
      "es are istergesstogetilly onteries ing bof cou h aentsiod that thiog te rompes coredyouknext of fraced win turly stould and louchain kave.\n",
      "\n",
      "The nofenderk tove inge basic summary of the story is that t\n",
      "\n",
      "\n",
      "iter :192500, loss:0.250450\n",
      "ctur components, thes together, carefurlecencobliges correctly.\n",
      "Pperasss.\n",
      "\n",
      "Chaidg will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases t\n",
      "\n",
      "\n",
      "iter :193000, loss:0.243631\n",
      "e and ourpy codyoure com ouplit of ark comacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion and \n",
      "\n",
      "\n",
      "iter :193500, loss:0.239816\n",
      " poupderyound into amm onner crachos the temuthone these compose tur couch unisitoryoug.\n",
      "\n",
      "The comm, prcep encercom? Noteditt bofricted contexts.\n",
      "\n",
      "The basic summary of the sterconcons Thatige coveratie\n",
      "\n",
      "\n",
      "iter :194000, loss:0.234301\n",
      "n pimuog context from contamination and overreaching from other compone.\n",
      "\n",
      "Componnteracts with other componenasisidd ladribge steasing on with other components.\n",
      "\n",
      "Ideally, we should ais fonented of ine \n",
      "\n",
      "\n",
      "iter :194500, loss:0.229723\n",
      "plited texts of im rould code that. The racr ges mpresis Pro nne coverats.\n",
      "\n",
      "When softcore. Pa, \n",
      "bfecines mos one components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The besis si\n",
      "\n",
      "\n",
      "iter :195000, loss:0.225555\n",
      " ses aon iaverrconsspents once tableacs.\n",
      "\n",
      "CouLinn and ouct component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, we\n",
      "\n",
      "\n",
      "iter :195500, loss:0.221532\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :196000, loss:0.218176\n",
      "TThe es of codere.\n",
      "\n",
      "Ther copric the code that changes or es on couclige ancemstot. Both addressthy pould merio be coup ing.\n",
      "\n",
      "Ite steckaus to understand and maintain if comwing m onting ysur acle highl\n",
      "\n",
      "\n",
      "iter :196500, loss:0.214715\n",
      "a wurt cuarh ifunted mamion anntrero make ethe thy sroulew.\n",
      "\n",
      "The more restricted your access level, the fewer chances to y urcary of the story is that things get much easier to understand and maintain\n",
      "\n",
      "\n",
      "iter :197000, loss:0.211584\n",
      "ed masyes of anderpons of sich components, these components will inevitably interact wot? hig Pratect, ablys, erite lew le lestexts.\n",
      "\n",
      "Ie Use surulith o entare in, doug.\n",
      "\n",
      "The change components.\n",
      "\n",
      "When s\n",
      "\n",
      "\n",
      "iter :197500, loss:0.208564\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "es bod wacleducturgcfers oney provide access to other packages through a ohe simut, and muri isith winction thi ge tur thew cous wot components, ase laver, ardellangeatemptand Packages coderasse bover\n",
      "\n",
      "\n",
      "iter :198000, loss:0.206541\n",
      "y thane nomem batare tasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would\n",
      "\n",
      "\n",
      "iter :198500, loss:0.203273\n",
      "arected objects.\n",
      "\n",
      "It's er ancess wor th wectass togetisto enterface, covering every bullices our thoun aes maricts Prom orgef canising unit tests for every bull inveruss once itherves a clmhorepasss.\n",
      "\n",
      "\n",
      "\n",
      "iter :199000, loss:0.202074\n",
      " Bothes tuges, nomponents crmhes.\n",
      "\n",
      "Ite wing ohes, and lothiage if yodeat cofuc and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays \n",
      "\n",
      "\n",
      "iter :199500, loss:0.199729\n",
      "ze todeprevicounat youlit indalize moull context froull for hoogether. Cogesient ef conte. Yopucting one code to with ancess mans ra ulique interfacecoderacsing othes, cuplicencoupling of casitill uen\n",
      "\n",
      "\n",
      "iter :200000, loss:0.197804\n",
      "plitewing on the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you d\n",
      "\n",
      "\n",
      "iter :200500, loss:0.196150\n",
      " ses suclderstend pull com?es sumpos macke are uady to makevery public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Check\n",
      "\n",
      "\n",
      "iter :201000, loss:0.194561\n",
      "or even replaced with cons in or iand yodele, compont, and uthes, sufrutlyo.\n",
      "\n",
      "The bo kh cemsontext amutice inotext aratf cofrerfacess, an once tans toge ssranst wig. Aoplitve. It Respond the component\n",
      "\n",
      "\n",
      "iter :201500, loss:0.676339\n",
      "Text impore, and ProductRepository are highly coupled; why. Pacrig.\n",
      "\n",
      "The more res muctRepther to elell's mather contexts.\n",
      "\n",
      "What do ProductRepositure yout code as beginnt to mame therrerterrercof bever\n",
      "\n",
      "\n",
      "iter :202000, loss:1.854268\n",
      "a uncorpendeconderves a common purpose stayly inting your code as beginners framework tutorials once tamponent your interfaces and inversion of codpling dublic! That.\n",
      "\n",
      "The basic summary of the story i\n",
      "\n",
      "\n",
      "iter :202500, loss:1.689878\n",
      "ed mathe thy. Prchite, arr of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Respo\n",
      "\n",
      "\n",
      "iter :203000, loss:1.239941\n",
      "esiserrerfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer intercom with a semponenderound allere compos de tout ho the code thot ont. Prorg thesion wit much maon cons inge. I\n",
      "\n",
      "\n",
      "iter :203500, loss:0.877317\n",
      "cteryos aonteck, ProductService, and ProductReposmanct ere is anting mouplid on components. It means one component can be changed orien ald lension tayin - the compliogemtonk hou prerkavedy.\n",
      "\n",
      "Couple i\n",
      "\n",
      "\n",
      "iter :204000, loss:0.640579\n",
      "ansexter throunder compone tsuthaces oug. Pichit coveding bole that changes togetorcontorkare rain kour code and wing means fewer interconnections across and o comain yobot ony, wo r archiction tha de\n",
      "\n",
      "\n",
      "iter :204500, loss:0.490963\n",
      " roher aflith fing yhec premadg of coderasss ane cemasig turl-defin comain knowledge in working code and protecting that knowledge in your context from contams wo knvely and main knoturis cout thea sa\n",
      "\n",
      "\n",
      "iter :205000, loss:0.393784\n",
      "n duplsus torain ing usitlyoneas es overy pavery. It recom cam thou cham onend.\n",
      "\n",
      "Thes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access leveld annec thane caprering us wit context fro\n",
      "\n",
      "\n",
      "iter :205500, loss:0.331720\n",
      "pliteed, bount ball on mmabltion ther.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behavi\n",
      "\n",
      "\n",
      "iter :206000, loss:0.291364\n",
      " conces that dew. Tha sis such ulititist tondeat you haver context from contamination annoulc avery public method of every class, write unit tests focusing on the component's public interface, coverin\n",
      "\n",
      "\n",
      "iter :206500, loss:0.264276\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, wind o ponent correctly. It in anderefry hove is a cunglet ance that will end up in a big bal\n",
      "\n",
      "\n",
      "iter :207000, loss:0.246335\n",
      "TRep corresiqte into and clat.\n",
      "\n",
      "The bace bound oneas ervice, and ProductReposur sif led of ing. Prowit. Peferect Baskes together stays together. The component can be changed or even replaced without i\n",
      "\n",
      "\n",
      "iter :207500, loss:0.233246\n",
      "a wurkages surp cunsqucr coracte thauces ass oney.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can es that thing ysotlingit interfaces and inversion\n",
      "\n",
      "\n",
      "iter :208000, loss:0.224174\n",
      "wderged of we cappest on tery ancteststing ysur code and protecting that knowlyc, tapunt ouplit inces complit Indefod athe componentarses of inte, wore rackaucess, sus morha such vericts siog the Sing\n",
      "\n",
      "\n",
      "iter :208500, loss:0.216860\n",
      "esisy ssosis to ess fodeland components, these components will inevitably interact with one anceplasse, pora sumpompour chated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to creat to or\n",
      "\n",
      "\n",
      "iter :209000, loss:0.212206\n",
      "ctestoome.\n",
      "\n",
      "Thee stefryonnt.\n",
      "\n",
      "The ecomponend erpos thy sesss of er int. Prowith you hade codpons should contain all classes of a specifill cematid ted.\n",
      "\n",
      "The more restricted your access level, the fewe\n",
      "\n",
      "\n",
      "iter :209500, loss:0.206860\n",
      "apy of thever into and ysacka er me veve is cout im oftinis sisill defendeptitu thacreructesio knor to or higes th concex, enit yo tebis dert ba inge uncessta ingqued theas duwing the domain knowledge\n",
      "\n",
      "\n",
      "iter :210000, loss:0.204418\n",
      " ghe por mactucfrcungem ontitisi\n",
      "ntablay oull-depents togeth. The nasisss ofsict murvesias esur to orkevedy pacle rof ery, and suchiog the component's public interfaces and in. Use westo know. Bo ung \n",
      "\n",
      "\n",
      "iter :210500, loss:0.201120\n",
      "n puctass together, carefully encapsutite access mar exp cemponents, the decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly def\n",
      "\n",
      "\n",
      "iter :211000, loss:0.198471\n",
      "pliteed, bountarserspack correctly. Praas toduct manges omposemsto ievery public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the u\n",
      "\n",
      "\n",
      "iter :211500, loss:0.196405\n",
      " simply, thin ats coshaclise tunldfone thew.t will-defriog veructndars corpes your arricls of y cuntly iflyctmaone corpes, and corges simplct, ProductRepo cod coderatheas ondyog tare ued component's p\n",
      "\n",
      "\n",
      "iter :212000, loss:0.194169\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :212500, loss:0.192543\n",
      "T to interstand and much uho to y hovaling gemptRer lode should aim for hing P)ringe s. gefceryon thaid Ites ens core osser.\n",
      "\n",
      "The dode, surk amuring ba ed crof control for low coupling.\n",
      "\n",
      "Low coupling \n",
      "\n",
      "\n",
      "iter :213000, loss:0.190466\n",
      "a uncorpendecopleak the dofur inind maintain if we can effectively drew coduls ass worentiple (e ehe story is thaid sises to lears cemract manc ma nop murvestay er to pesion w the chppled once that wi\n",
      "\n",
      "\n",
      "iter :213500, loss:0.188797\n",
      "ed mathe toblever framed th w tomponer esurutict yould be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other co\n",
      "\n",
      "\n",
      "iter :214000, loss:0.186869\n",
      "es entes ofeact caprest dofleple steation to make othe say smak the noun the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during de\n",
      "\n",
      "\n",
      "iter :214500, loss:0.186062\n",
      "ctestoopemati\n",
      "nt des werr inge sha lia na ro urketecress andull-defier ed or evene.\n",
      "\n",
      "Ite doderaysextrod contain ald oracsif intepo ithe dupletest. Cohest.\n",
      "\n",
      "The code are suciesic summary of the story i\n",
      "\n",
      "\n",
      "iter :215000, loss:0.183720\n",
      "are thasle ssewilly entaraog is to unk dour code ant inverurc and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. boverrcor?e depl pich thout\n",
      "\n",
      "\n",
      "iter :215500, loss:0.183469\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " wobl com ong I hopy ur changes to ererpeconces th arkpowetig timk, inged porpone lings or with wictle sturpy unuthendow cann I hoper of coupling foapentoreld conces comyonend othe composed intortieg \n",
      "\n",
      "\n",
      "iter :216000, loss:0.182111\n",
      "n duplsus to are theucthet ouplit intain if your arutinl us the nace component'rass cuns uth ofuray.\n",
      "\n",
      "Compont howy urkigeer fonteins enyour podontes. Nofer ouciss wos con dere int. The codedasist, and\n",
      "\n",
      "\n",
      "iter :216500, loss:0.180829\n",
      "pliteed, the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and \n",
      "\n",
      "\n",
      "iter :217000, loss:0.179972\n",
      " sald basis oupt ontars fles, bodeite raen stays the gests ons mauge conces that todlicess you n ende noge in ances that yould nompendr that sing meand orperkage jest if your ar poundarrertherythings \n",
      "\n",
      "\n",
      "iter :217500, loss:0.178763\n",
      "or even replaced without impacting other components whacsising unly providg the athe Yould clate thy uricize ioveracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling\n",
      "\n",
      "\n",
      "iter :218000, loss:0.178004\n",
      "TReptiog the component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one anot\n",
      "\n",
      "\n",
      "iter :218500, loss:0.176871\n",
      "a turibly if ary com cos ons mapy orite, that wo khouc ially, bbo coucle merrercompose wonedrean mmroore code. Yourecos and luthinged or evar. Use we hmaes indess ane ithery public method ot onessios \n",
      "\n",
      "\n",
      "iter :219000, loss:0.175898\n",
      "ed mates that codeath ciplerk the cthaure, mounte, and The code. Your code should reflect the architecture dia sofrearest, wiog that knowledge in your context fopes.\n",
      "\n",
      "Ides that dog. Apples abling te a\n",
      "\n",
      "\n",
      "iter :219500, loss:0.174743\n",
      "es ene. The basitlyos to sis ing uto understand and much mametrer ores throrebo your acru Nheryode the iot yveviting ouling tigly onond cont is eraas to are suche ungeld on the component's public inte\n",
      "\n",
      "\n",
      "iter :220000, loss:0.174563\n",
      "y Nothie\n",
      "\n",
      "nt anr corpes components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low couplingle sucurtectly. It if oveccipg ain corucier thanges togethrrogyot. Checkout my article about effective tes\n",
      "\n",
      "\n",
      "iter :220500, loss:0.172841\n",
      "e and markily cho ject your access together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is ab\n",
      "\n",
      "\n",
      "iter :221000, loss:0.173096\n",
      " woreracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion ancend or inde smat will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make other ove nou houp arm?facce\n",
      "\n",
      "\n",
      "iter :221500, loss:0.172311\n",
      "n duplsusito tout wilile derp on the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are\n",
      "\n",
      "\n",
      "iter :222000, loss:0.171405\n",
      "pliteed, the components clearly annomecout couplith ould bounder aon context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? No\n",
      "\n",
      "\n",
      "iter :222500, loss:0.170883\n",
      " sems once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from other ofer concess marhe compose toure inouctining unit \n",
      "\n",
      "\n",
      "iter :223000, loss:0.170018\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :223500, loss:0.169459\n",
      "The chmacconte in entara lestonent bould cenconsatl on mempony dricherster, and oryondefropint oreale ev an. Thour thew components. It means one component can be changed or even replaced without impac\n",
      "\n",
      "\n",
      "iter :224000, loss:0.168655\n",
      "all cou houb we resuctReptorests publt mathess bomesion as entecturgse wonligelly toner iasiss must dele ma s aus to understand and maintain if your architectural ideas map explicitly into the code. Y\n",
      "\n",
      "\n",
      "iter :224500, loss:0.167819\n",
      "ed public! That will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything puble hia poremacthes, and s that things get much easier to understand and maintain if we can eff\n",
      "\n",
      "\n",
      "iter :225000, loss:0.166961\n",
      "esising y ho y styotRexta notict your code proflect, ProductServiconseryined pout ind muck horempopented porpos and interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling tive that.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :225500, loss:0.166962\n",
      "d ontextly. Pach unner coveding and and maed context on such ohe ais cod wacsest bour to understand and maintain if we can effectively draw and enforce boundaries during deveais ald or even wit laslly\n",
      "\n",
      "\n",
      "iter :226000, loss:0.165562\n",
      "are te cleasion the gom more is code and th auntrereflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stotext ann context and only provide access to other packages through\n",
      "\n",
      "\n",
      "iter :226500, loss:0.166101\n",
      " po reand anithit codeate rapupnnouns forpese, ank fromaing orged ofrio cuplicem tarnterster, and led anly context from contamint commoncostays th tewit. Pvinint contexts.\n",
      "\n",
      "What do Prosucthes togethes\n",
      "\n",
      "\n",
      "iter :227000, loss:0.291328\n",
      "dill devect, ProductService, and ProductRepository are highly coupled; why would not you group coupling means ofes, wulla lew is wices and inversit yh a smatig I hope you have understhat sead onnes to\n",
      "\n",
      "\n",
      "iter :227500, loss:1.786744\n",
      "pliteed and components.\n",
      "\n",
      "Ideally, we should aim fer over corpesising om on highly tucwinn antexs of ana serale is ancessuruteratinn enco that will end up in a big ball of mud.\n",
      "\n",
      "We need to reprery, wno\n",
      "\n",
      "\n",
      "iter :228000, loss:1.756824\n",
      "d intorein if y penct, aninl-ew, in that things get much easier to understand and maintain if ylle components clearly announces their purpose, and such a unit de rhe foflec.\n",
      "\n",
      "The desting ysurkacour in\n",
      "\n",
      "\n",
      "iter :228500, loss:1.369498\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When sofrot ento snaurated semposictllaced arr urhacy.\n",
      "\n",
      "Then, instead. Coverucontext and only provide access to other packages through a unique in\n",
      "\n",
      "\n",
      "iter :229000, loss:0.954104\n",
      "The dampos mable eroupling. Apply the Sing bo that thing on cos andes tn creffectively draw and ductay. Ppctasis one nou the story is that things get much easier to understand and maintain if your arc\n",
      "\n",
      "\n",
      "iter :229500, loss:0.676913\n",
      "a wurict BasketRepository have in common? Nothing. Both address different problems, so why groupes.\n",
      "\n",
      "Ides to understand and maintain if we can effectively draw arcode arg in thece, and ProductService,\n",
      "\n",
      "\n",
      "iter :230000, loss:0.502193\n",
      "ed maties dublly. Packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing u\n",
      "\n",
      "\n",
      "iter :230500, loss:0.391950\n",
      "dere coves, and contad bour core iever, and compest, and cturfaces component ervice, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, \n",
      "\n",
      "\n",
      "iter :231000, loss:0.322688\n",
      "ite aine depectmadd uboupess, sum oreld and control for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across componen\n",
      "\n",
      "\n",
      "iter :231500, loss:0.276921\n",
      "e compom raod overreacims, wnod of them together, carefilly wecthyuct, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together\n",
      "\n",
      "\n",
      "iter :232000, loss:0.248800\n",
      " wory and annes totedint together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important\n",
      "\n",
      "\n",
      "iter :232500, loss:0.229640\n",
      "nig enterconnections across components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and i\n",
      "\n",
      "\n",
      "iter :233000, loss:0.216448\n",
      "plioned interfaces and inversion of control for low couc ings to arevevena d oup int gourt ras sige dapunt's es commonges together, stays to compos components.\n",
      "\n",
      "Ideally, we should aim for high cohesio\n",
      "\n",
      "\n",
      "iter :233500, loss:0.207553\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " in enting Pmyot dr thesion we that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of intercontain your architect\n",
      "\n",
      "\n",
      "iter :234000, loss:0.200691\n",
      "or even replaced without impacting other thaw intere compose tor pould ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, ca\n",
      "\n",
      "\n",
      "iter :234500, loss:0.195863\n",
      "TRepties the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and \n",
      "\n",
      "\n",
      "iter :235000, loss:0.191664\n",
      "a turicims mesth couct ore ierentibly pm chat we urkacle es the next important thing you need to lecrief that. \n",
      "Iterrobl ingepled lout im oh wouthit with wing.\n",
      "\n",
      "The postogetinl compend and BasketRepos\n",
      "\n",
      "\n",
      "iter :235500, loss:0.188491\n",
      "wine hould gequctint can be er if reacempry uria d conthie d ing ble your pung unill ine comcout th we unith coull ucuplaced without impacting other components.\n",
      "\n",
      "When software is decomposed into small\n",
      "\n",
      "\n",
      "iter :236000, loss:0.185555\n",
      "rer sufilly sigh concess ofring mesithaes to are ur oned thats ceme, anl- to yos, acs hout ef acsing other components.\n",
      "\n",
      "When stogetis ance surlithie The component cant compom ohy th oumpentive tay urp\n",
      "\n",
      "\n",
      "iter :236500, loss:0.184556\n",
      "y bound andode, contectsRepteraceati\n",
      "\n",
      "The coduct component can be changed or even replaced without co chatectite cesply unceclary of the code that serves a common purpose stays together. Cohesion is a\n",
      "\n",
      "\n",
      "iter :237000, loss:0.183221\n",
      "e ances the res ro arainer eve are somponent correctly. It is about how much one component depends on for frewricill as tuctRepes ofsict wigents.\n",
      "\n",
      "Ideald interfaces and inversion of control for low co\n",
      "\n",
      "\n",
      "iter :237500, loss:0.181485\n",
      " ro enaaditurgsul one dupleding dout coure thaud onderacts with other components.\n",
      "\n",
      "Idealle lrogether, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances \n",
      "\n",
      "\n",
      "iter :238000, loss:0.178988\n",
      "n thes condeplasion intisull mor? seatly uther the und with unces to and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, \n",
      "\n",
      "\n",
      "iter :238500, loss:0.176562\n",
      "pliore) for anness, s sutinle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one\n",
      "\n",
      "\n",
      "iter :239000, loss:0.174979\n",
      " sista ka the nome components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists o\n",
      "\n",
      "\n",
      "iter :239500, loss:0.173021\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :240000, loss:0.171656\n",
      "TThe es of could he componenasss of control for low complit myour to un ar interas surl-deraoce, and Poreratitory to tieg that things get much easier to understand and maintain if we can effectively d\n",
      "\n",
      "\n",
      "iter :240500, loss:0.170043\n",
      "a wuricly thand poup archit conke ofotheass onceat tests and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, careffod con\n",
      "\n",
      "\n",
      "iter :241000, loss:0.168694\n",
      "ed make roferyould you nceadd ound Basket ais It ketospendofro understand and maintain if we can effectively draw and enforce boundaries during deveapllw cive testing\n",
      "\n",
      "Components with a singly, contes\n",
      "\n",
      "\n",
      "iter :241500, loss:0.167132\n",
      "rer sufic er context from other ofed context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different pr\n",
      "\n",
      "\n",
      "iter :242000, loss:0.166489\n",
      "y bohain ifry wodact baes to understand and maintain if we can effectively draw and enforce boundaries during deve ismaly ho are easy to understand and maintain ifew to understand and maintain if we c\n",
      "\n",
      "\n",
      "iter :242500, loss:0.164729\n",
      "anse component depends on or interacts with other components.\n",
      "\n",
      "Ideate untine tam thallinges.\n",
      "\n",
      "The caputill you d encarcess onysitinlly clms.\n",
      "\n",
      "Coupesion th unded shaw components.\n",
      "\n",
      "Ideally, we should ai\n",
      "\n",
      "\n",
      "iter :243000, loss:0.164520\n",
      " ro enacle sio und onis to make oh thot is wuy. Copa is or ave arupcompletrontane interfaces and inversion of controo ather to on commongep or wecres cons and in th weth fow tha sic int pent Thact yos\n",
      "\n",
      "\n",
      "iter :243500, loss:0.163882\n",
      "n tu ingllly wr com fow cavetarnile oncercont ing.\n",
      "\n",
      "Then, dill end pund plamst.\n",
      "g thaall compopentarios tune debrigh conesion ans together, carefully encapsulated.\n",
      "\n",
      "Th sall codgeplepled or ed of chic \n",
      "\n",
      "\n",
      "iter :244000, loss:0.162710\n",
      "plione corch component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Componerforce boundarit how coupling. Apply the Single Responsibility Prin\n",
      "\n",
      "\n",
      "iter :244500, loss:0.170964\n",
      " sesind otRenondeder.\n",
      "g to er ofrcofecting one cocreyly ubit taow inte codtige core teatl onces the dom ont. govedurind ioge cour ponenderr acner ances that thy urh coure should a tuch ile sists code \n",
      "\n",
      "\n",
      "iter :245000, loss:1.780879\n",
      "or even code thy uring beving means ontext ysurka er entedurlco. Your pouning means fewer intor ibjuct and worerated semtse. Cogesion all de w your code and proter or evining imyotrcbou dupkand I hope\n",
      "\n",
      "\n",
      "iter :245500, loss:2.241417\n",
      "Text ing dup sthice, and lyctict ro togeting is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we sho\n",
      "\n",
      "\n",
      "iter :246000, loss:1.798890\n",
      "a turiciss is or the coderatidy censsilg eracka etorke for hie kane nead pur ing inot to touness, somponj suctReatssesting un the Single Responsibility Principle (SRP) for high cohesion. Use well-d li\n",
      "\n",
      "\n",
      "iter :246500, loss:1.233609\n",
      "ed mapy of the story is that things get much easier to understand and maintain if we cad dery hipglemuche doffacterkiges bo lecouplyo pomponentsie ing urlicencoupling.\n",
      "\n",
      "Low coupling means fewer interc\n",
      "\n",
      "\n",
      "iter :247000, loss:0.863640\n",
      "esily hia is one no quapystous in comutncts common purpode endarges ta l sicon tadd athe sterfaching from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepos\n",
      "\n",
      "\n",
      "iter :247500, loss:0.626952\n",
      "ctestoble iode ur code and protecting that knowledge in your context from contamination and of my paon thew comulcomponents onces th iviting isitur interface.\n",
      "\n",
      "Then, instead of writing unit tests for \n",
      "\n",
      "\n",
      "iter :248000, loss:0.474136\n",
      "e and ouro sacundes that thou dact yout if in conteins fearcodges components. It means one component can be ebling Choule into and coatisiald uncestays toteres ont. Cohempond os and munonderr ancones \n",
      "\n",
      "\n",
      "iter :248500, loss:0.376117\n",
      " ro enacturfices and in totings get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve ismaly of preve as cofeverablalectitg you decrerh yout code is \n",
      "\n",
      "\n",
      "iter :249000, loss:0.312817\n",
      "n ertarkale baon mafroup them together?\n",
      "Product, Promain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from contamination and overreaching\n",
      "\n",
      "\n",
      "iter :249500, loss:0.270736\n",
      "pliteederfais to understand and maintain if we can effectively draw and enforce boundaries during deve is ahacle eviriog ofrect, and ducomposed into smaller components, these components will inevitabl\n",
      "\n",
      "\n",
      "iter :250000, loss:0.243694\n",
      " ses aod in pose ithe archite, ave smurhe code they thefrcemposedtand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summ\n",
      "\n",
      "\n",
      "iter :250500, loss:0.225135\n",
      "or even replaced without impacting other component depribly he ams of control for low coupling.\n",
      "\n",
      "Low couplingem to Cothe ulliconces th context from contamination and overreaching from other contexts.\n",
      "\n",
      "\n",
      "\n",
      "iter :251000, loss:0.212798\n",
      "T todunt doug.\n",
      "\n",
      "Coupt, know com one for how of ile cour changefle (SRP) for high cohesiog of components clearly ann cos enot ang couplinnte, and such a unit do ?tera ssibility Pring wit.\n",
      "\n",
      "The cheatis \n",
      "\n",
      "\n",
      "iter :251500, loss:0.204179\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a wurkilge itver, ither components.\n",
      "\n",
      "Ideald conea domain/context anly hestryot cofrepull aum ass one code teat youpling mea smarke, anlene isible iod io Prodectho knto pout aru uns understand and main\n",
      "\n",
      "\n",
      "iter :252000, loss:0.197561\n",
      "ed mathe togleasitReponnent prinnt es of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of\n",
      "\n",
      "\n",
      "iter :252500, loss:0.193021\n",
      "esily urganize your puch understand and maintain if your archings get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve ismaly ho arequchand ourpy co\n",
      "\n",
      "\n",
      "iter :253000, loss:0.190094\n",
      "y bound andod of wleass unces to enosurcof inic and of inderponenteratssentstowit xast is that ys Pfot yould be capturing thergent yound thef oryoveng. The contais and maintain if we cinces the domain\n",
      "\n",
      "\n",
      "iter :253500, loss:0.185585\n",
      "e ancepencom rhain if ylaced why inger es cout intexts weracls ons dout code ain the ung bouplith fow youray smerpribly inot thy pour pono urkances to creply simply coure that will end up in a big bal\n",
      "\n",
      "\n",
      "iter :254000, loss:0.182941\n",
      " wobl components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably inte\n",
      "\n",
      "\n",
      "iter :254500, loss:0.180466\n",
      "n witlyone component depends on or interacts with other cofpine anoskentaod interfaces aur in wet yode arn tibla stoulackess understarathe thyod deprerille, more readlit in dearlyodedalllewe component\n",
      "\n",
      "\n",
      "iter :255000, loss:0.178828\n",
      "plitre intiog thet things get much easier to understand and maintain if yhit in togr coded codry components, these components will inevitably interact wnin.\n",
      "\n",
      "peslace domaines en thandes together, stay\n",
      "\n",
      "\n",
      "iter :255500, loss:0.178260\n",
      " inow andepstory is that yould rohe athwitinn all consly urly commoncode iframerother, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of co\n",
      "\n",
      "\n",
      "iter :256000, loss:0.176226\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :256500, loss:0.173493\n",
      "Textnon of ing. Pepecheryous of corperhor arhes of knge\n",
      "nog mofle he are coduratsing ysurking fode and in antays mapy hotext and otu are uapy to the component's public interface, covering every behavi\n",
      "\n",
      "\n",
      "iter :257000, loss:0.171195\n",
      "a we components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a sadiss a stould ats unie inderser or\n",
      "\n",
      "\n",
      "iter :257500, loss:0.169092\n",
      "ll-defined purpose are eacemar enonded ifly acyonent component ing purgelly ofosioge components.\n",
      "\n",
      "When software is decomposed into that we and componender, cod coupkcomponed suro testing dublic! That \n",
      "\n",
      "\n",
      "iter :258000, loss:0.168418\n",
      "esisind interface.\n",
      "\n",
      "Then, instead of writing unit tests for evernot the chans ofetera duponkevedy that inderint chary of thats comebllito.\n",
      "\n",
      "Then stotkont domall cohesion. Use well-defined. kast beated\n",
      "\n",
      "\n",
      "iter :258500, loss:0.167148\n",
      "ctesting ysur code arn the ghing des, ruplices ouplid coupling. Apply the Single Responsibility Princowettesss ouplinge coneatr compriplected ou nes essund ancomyoted turvitiog ofreskr fou cheply cone\n",
      "\n",
      "\n",
      "iter :259000, loss:0.164460\n",
      "e ancemsther, carefully encapsulated.\n",
      "\n",
      "The more reffrcompose.\n",
      "\n",
      "Ide steasisy that knowlec, tapk gemponene camponents will yould ublyain if y howilg ulicles es of a specific domain/context and only prov\n",
      "\n",
      "\n",
      "iter :259500, loss:0.163840\n",
      " roveraccugether, cade thould atstest, and stot yoly arcensiffer, arctests wable wiag tigeg the ro are ka enan ssurka y hode arrates tarnted. Paplerg bulling Pe conce it to leak the domain. The racr e\n",
      "\n",
      "\n",
      "iter :260000, loss:0.163126\n",
      "n deat endenciple (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component c\n",
      "\n",
      "\n",
      "iter :260500, loss:0.161519\n",
      "pliteedine lesif ing utitled components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that \n",
      "\n",
      "\n",
      "iter :261000, loss:0.160704\n",
      " sisin ingll, onever, and indere comross, pour ariting unill ing ung bould be contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why\n",
      "\n",
      "\n",
      "iter :261500, loss:0.159356\n",
      "or even replaced without codrprer ances to clath inew, inot mm onkevery pa int Baideadyoblat your pom oraceste sturficesion - the code that changes together, stays together, stays that knowithe depely\n",
      "\n",
      "\n",
      "iter :262000, loss:0.158178\n",
      "TReptictest, and Ptoge ind im ancodeatly uther thy grall covispode concer fresion ind otRenone component depends on or interacts one Refrour int depesithw one hervere is orpergroun arcune pis ente com\n",
      "\n",
      "\n",
      "iter :262500, loss:0.157106\n",
      "agle component can be changed or even replaced without coupling m anterestabi le siceston. Use it thane noup ing ure theald conderything ghoupled towy arly and enceplary to onte. Bohe inoe ta s feveck\n",
      "\n",
      "\n",
      "iter :263000, loss:0.155847\n",
      "ed mathe tompos objects.\n",
      "\n",
      "The bound rewnais to understand and maintain if of cemcedonteml, and Pfode thy urict brod cacessintore crout co thatyog of cob unhen assists basy pouraced and ro ecrich taugh\n",
      "\n",
      "\n",
      "iter :263500, loss:0.154725\n",
      "rsi\n",
      "\n",
      "Ides that ys?rkale r ffrowithe dependerenctists in thit ing ony mres of writing desting\n",
      "\n",
      "Components with on? Nothing. Both address different problems, so why group them togethes?\n",
      "It asst.\n",
      "\n",
      "\n",
      "\n",
      "Then\n",
      "\n",
      "\n",
      "iter :264000, loss:0.154047\n",
      "ctestobly tu are ain ingeble code to understand and maintain if we can effectively draw and enforce boundaries during deveapllored thin ats ons ces endept medt, at. Chompomerable coure theuct cive tes\n",
      "\n",
      "\n",
      "iter :264500, loss:0.152286\n",
      "e enoed or ereate, mouges comsibopes conterconges components.\n",
      "\n",
      "Ideally, we should aim for high cohes with fow hoo youldaon mamkenos to understand and much more readable. The name of such components cl\n",
      "\n",
      "\n",
      "iter :265000, loss:0.152155\n",
      " ro enacturtReposithe code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more res muctReptsstorit in ingqullacthet efuc and uup ences Ins sumlith ohes.\n",
      "\n",
      "The pomponende, athinges \n",
      "\n",
      "\n",
      "iter :265500, loss:0.151393\n",
      "s able would merines stay chates of roduct thing BasketRepository have in common? Nothing. Both address different problems, so why group them togethergod oune s menting\n",
      "ents.\n",
      "\n",
      "When software is decompo\n",
      "\n",
      "\n",
      "iter :266000, loss:0.150005\n",
      "pliteederes commone lingle, components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfacesion. U\n",
      "\n",
      "\n",
      "iter :266500, loss:0.149365\n",
      " temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a s\n",
      "\n",
      "\n",
      "iter :267000, loss:0.148317\n",
      "will couply.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout \n",
      "\n",
      "\n",
      "iter :267500, loss:0.147474\n",
      "TRef onted.\n",
      "\n",
      "The more restricted your access level, the fent conteris werel! That boferyod inic ancode ant things get much easier to understand and maintain if we can effectively draw and enforce boun\n",
      "\n",
      "\n",
      "iter :268000, loss:0.146740\n",
      "a uugha dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn interfaces and inversion of conty.ply ho yosewing le\n",
      "\n",
      "\n",
      "iter :268500, loss:0.145698\n",
      "wind with uidLowly ProductRepterother coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibilit\n",
      "\n",
      "\n",
      "iter :269000, loss:0.145077\n",
      "text ang. Itsils leat. Boge notes able coure the code to ore forect, and ul ancere ither components, these components will inevitably interact with one another, and it will require clearly defined bou\n",
      "\n",
      "\n",
      "iter :269500, loss:0.145357\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ctestonnesstersterand of we interface, covering ever os of ing.\n",
      "\n",
      "Weed iogedare is ans toduct ann cootext from otherore te. \n",
      "\n",
      "Chy centing your code as th if cansistr context em om os fone bovedgit the \n",
      "\n",
      "\n",
      "iter :270000, loss:0.170987\n",
      "e ancterathe ong. Apply tugf compos coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-definede more readable. The name of such components clearly cings together, ca\n",
      "\n",
      "\n",
      "iter :270500, loss:1.140371\n",
      " Bothes tugessentigige coher cabouRextsit. Thout wer, arasista s murgesig. Thes todull-defer cound that will end up in a bou the ses a cleasions Use ith wing mevin -ut ro tay. Th we abogher ofed conte\n",
      "\n",
      "\n",
      "iter :271000, loss:1.230488\n",
      "n thanges to are sseckaucess, domadill ing blaw.\n",
      "\n",
      "\n",
      "Low coupling means fewer interconnections across components. It toget corres oncectseand ta is lr es the next on aon contain ald an tect, and leconte\n",
      "\n",
      "\n",
      "iter :271500, loss:0.900594\n",
      "plione hempod wont ou inge wond pos codeath o everythyour ro make other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high\n",
      "\n",
      "\n",
      "iter :272000, loss:0.637338\n",
      " tempod longes mas mathe sering onysithy torpling meprovers wspes qmmra thet ene. Thang cout couchang I oupt tould bot you group them? Cohesion - the code that changes together, stays together, carefu\n",
      "\n",
      "\n",
      "iter :272500, loss:0.467949\n",
      "onge coverinc as ante, and congect yout re thew the Single Responsibility Principle (SRP) for high cohesion. Use well-defandergess mare codulize areais to understand and maintain if components.\n",
      "\n",
      "Ideal\n",
      "\n",
      "\n",
      "iter :273000, loss:0.359526\n",
      "The dampodepciblly won puapk should ais components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined inte\n",
      "\n",
      "\n",
      "iter :273500, loss:0.290379\n",
      "a ungark ghog that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do areasy acour yout annow thew counat thing ysaclacsing desuwit ing pubit punp coneatl once\n",
      "\n",
      "\n",
      "iter :274000, loss:0.245164\n",
      "ed public! That is wit krayl, aru Prompectsilp ifly to are simurathe urvery publyouThe stoge is a intering cooge concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thi\n",
      "\n",
      "\n",
      "iter :274500, loss:0.216123\n",
      "durtitosked for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout mydall component's public! That.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :275000, loss:0.197232\n",
      "ctess togedint with one ancepoturowicteducthesstand and maintain if your architectural ideas mapes oubn com fows onos to understand and maintain if we hr teatesting feed; why your po rever context fro\n",
      "\n",
      "\n",
      "iter :275500, loss:0.183568\n",
      "a erays todull-defined purpose are smecifitl co chos ona d compeng ony correctly. Pain a bagle ssserothed compodent proed anc conont ofed unces that you draw.\n",
      "\n",
      "The code that changes smances the nher s\n",
      "\n",
      "\n",
      "iter :276000, loss:0.175495\n",
      " wonc dont your to understargughanges of o yhur code as sha shesics of ine correctes thit ciak empribly pa siog that things to Praylathe component depends on or interacts with other components.\n",
      "\n",
      "Ideal\n",
      "\n",
      "\n",
      "iter :276500, loss:0.168968\n",
      "n thacle.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even erpest od contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common\n",
      "\n",
      "\n",
      "iter :277000, loss:0.164039\n",
      "pliteederes components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will wighly co\n",
      "\n",
      "\n",
      "iter :277500, loss:0.160473\n",
      " sisio y shit yodetarit yfonet ifly anteracle boundar into therctncontain ald overrcontext froucttes s abline dapunts comuling is together suricturing luries into e arvery publind aterything public! T\n",
      "\n",
      "\n",
      "iter :278000, loss:0.157528\n",
      "or even replyos togeturing bout hew is with ohether.\n",
      "\n",
      "The basic summary toges enteyconot effecting other components.\n",
      "\n",
      "When stoty are asst co mavedy puplaces shavicofly thace tall he bound oferething p\n",
      "\n",
      "\n",
      "iter :278500, loss:0.155040\n",
      "T to preclacees che refuntr pontact da t heatide ysurka componentsialy the sefry components onces that dewing ontext any corpess suctively ssig It mofre code that serves a common purpose stays togethe\n",
      "\n",
      "\n",
      "iter :279000, loss:0.153223\n",
      "a uh components clearly undectura turfices and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewectand and much more readable. The name of such components clearly announces their porkates\n",
      "\n",
      "\n",
      "iter :279500, loss:0.151164\n",
      "ed make er are coderated thay cosising lsur code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository \n",
      "\n",
      "\n",
      "iter :280000, loss:0.149729\n",
      "esily urganize your packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique ka mabind acsess bounded contexts.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :280500, loss:0.148831\n",
      "ctestople ithe oog the unnesponsions enderes andurw for every antemsser tound orit im orinntion and code arrecthe iog the domain knowledge in workinger ored contexts to understand and much mhis theryo\n",
      "\n",
      "\n",
      "iter :281000, loss:0.146899\n",
      "e and lofrigve sobje toull our the corgoflect, ProductService, and Proge cemasinnt eviclle codewitit. Prorke concer onged undeplasing pull require clearly defined boundaries not to leak bof inderetien\n",
      "\n",
      "\n",
      "iter :281500, loss:0.154960\n",
      " ro enasssing m to to he bourd that. \n",
      "Iterain cuns fouthy sing clearetiog fows co text ann context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketReposit\n",
      "\n",
      "\n",
      "iter :282000, loss:0.152339\n",
      "d domponnt.\n",
      "\n",
      "Weenesisill oup inded th.w. The code that sing m acies annos tofer ofecemposedts.\n",
      "\n",
      "The capleve urcode ann siytsimre thy component's public interface, covering every behaviour of the unit.\n",
      "\n",
      "\n",
      "iter :282500, loss:0.149153\n",
      "plitiontistr cound pome, and core reffro uakevendict your access level, the fewer chances to create or oupucfims on th ro ofring esuche ur theur ive are code that serves a common purpose stays togethe\n",
      "\n",
      "\n",
      "iter :283000, loss:0.147246\n",
      " concept, an meacis end fecthes of wrouc isea smams togeding. Apply ro siceice tevict, Promponents and onos to cleat youpled.\n",
      "\n",
      "The component's public interface, covering every behaviour of the unit. C\n",
      "\n",
      "\n",
      "iter :283500, loss:0.145192\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components onces th cohes ang b he ba i me, and if cantais abotiere youctsectur components, these compone\n",
      "\n",
      "\n",
      "iter :284000, loss:0.143966\n",
      "TThe ais is the fempod macumront aruponderstand and maintain if we can iff comttion all cly urith wize gests fecos chaencessonethe, comprconser.\n",
      "\n",
      "The code that changes together stays together. The cod\n",
      "\n",
      "\n",
      "iter :284500, loss:0.142538\n",
      "a we theplyont efed unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into ino extsit. Checkout my\n",
      "\n",
      "\n",
      "iter :285000, loss:0.140766\n",
      "wderked objectsit. Coupt tore cimpund bllay will end up impamm of corperothe hap chigg cleally, wo mame stactedallane dofew coupling omponeracs obj compomether to understary nthes the domposited bout \n",
      "\n",
      "\n",
      "iter :285500, loss:0.139495\n",
      "esiserstand and maintain if we can effectively draw and enforce boundaries during devicisly cansald interfaces and inversion of control for low couplill context from contamination and overreaching fro\n",
      "\n",
      "\n",
      "iter :286000, loss:0.138718\n",
      "y coupled routesss.\n",
      "\n",
      "Idelllew ithed of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of e\n",
      "\n",
      "\n",
      "iter :286500, loss:0.136892\n",
      "a etsemplling main a couct your to undersepo is aes to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you dra\n",
      "\n",
      "\n",
      "iter :287000, loss:0.136741\n",
      " wobl components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Sinnle corpesgronka tu and couplinde.\n",
      "\n",
      "Ideplr contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in \n",
      "\n",
      "\n",
      "iter :287500, loss:0.135769\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n dit much maon cont ia evicning frepllere is anss ane ithathingr cout im on if your avela ising one Revict, abullerroble co eroticly phat youl comyos d about effective tour access masses of a urkande\n",
      "\n",
      "\n",
      "iter :288000, loss:0.134734\n",
      "plitre, bonwy praal of mupl-dapliag tige context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository hrvect if yod ofrercometsemtodeets one compone\n",
      "\n",
      "\n",
      "iter :288500, loss:0.134018\n",
      " temptation to ariclly. It is a sha le arc ive context fry coduras mapuld a huchary somponetheves of ented meprevitictinly should contain ound to rig In illas mas Profulither aon? Nothinging le the fe\n",
      "\n",
      "\n",
      "iter :289000, loss:0.133225\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :289500, loss:0.132438\n",
      "TReptiog one suructs.\n",
      "\n",
      "\n",
      "The fofry peation theay d oupt eand ponent's public! rontext four.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends\n",
      "\n",
      "\n",
      "iter :290000, loss:0.131890\n",
      "a unhad contack dour context froup inep -oforcinhes components. It movedy packa yow of roul plinewith on sicon thew coms context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do Produ\n",
      "\n",
      "\n",
      "iter :290500, loss:0.130923\n",
      "ed public! That the shat ys of thoug. Pputhy und wly wrowitive to tog codr components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to\n",
      "\n",
      "\n",
      "iter :291000, loss:0.130362\n",
      "esisy sually surh cumsontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and Basklt char evenar pa r eviol component depends on or internot efou components, the\n",
      "\n",
      "\n",
      "iter :291500, loss:0.130208\n",
      "y bound andeconithergerill arcodgechinges tnow th or the story acing urit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every be\n",
      "\n",
      "\n",
      "iter :292000, loss:0.128920\n",
      "apees fuctand and maintain if cungs tomped contexts.\n",
      "\n",
      "It's enot.\n",
      "\n",
      "Coer ann coupd oneas eves ty orebleresperer simk ghe codew idversion creat yoderacthes, and Indepontary orabge the sint eviond why gro\n",
      "\n",
      "\n",
      "iter :292500, loss:0.129168\n",
      " wory and overy publind ot encoutint yould ur oracespes to sterrouncerror ences that your pfod cout toda touc and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have\n",
      "\n",
      "\n",
      "iter :293000, loss:0.128611\n",
      "n erayss.\n",
      "\n",
      "Wha r fouplind obllrorlyound and much more readable. The name of such components onces th cohe er a mould component's more res acceve uritn ade inverres coppes shoun thectestog poup aritinl\n",
      "\n",
      "\n",
      "iter :293500, loss:0.127874\n",
      "pes compemt, ProductService, and unly problems, co cefra kr commsigh concexthing of yode thould atss lle correctly orea interface, covering every behaviour of the unit. Checkout my article about effec\n",
      "\n",
      "\n",
      "iter :294000, loss:0.127437\n",
      " concept, and poneneas essemtonte singly. Pach uRuconsion interfaces aud thit coduls suring fous turg bive le rach thotext dfacs ructurore theat youpling means fewer interfacner code the cod corrowint\n",
      "\n",
      "\n",
      "iter :294500, loss:0.126877\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :295000, loss:0.126292\n",
      "T to preclametassesssmanstot. go sicresu nous to unt corectmain sestonselllew is wices and inveracts withy sual douply whuc main/context and onouns and much more readable. The name of such components \n",
      "\n",
      "\n",
      "iter :295500, loss:0.125930\n",
      "a uunt dur. The nepes ta learlyr amuthitg togedare is ont deplare teffrcompose Usur the fode should aint ero underats together, carefiog your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By\n",
      "\n",
      "\n",
      "iter :296000, loss:0.125140\n",
      "ed mathe tobleveckand outh uans access of concrow cofle (SRout and ba ee thoun ave steasisid be thay thin ald control for low couply whingse, anlene isurit tests of could arcume complit. Checka en ant\n",
      "\n",
      "\n",
      "iter :296500, loss:0.124733\n",
      "rergstats togesiog beverucorwerestsyour pach shmald incepssither, itewit inge taging component your poud anness onces to creary compore, and ProductRepository are highly coupled; why would not you gro\n",
      "\n",
      "\n",
      "iter :297000, loss:0.124925\n",
      "clarint conew thet, stoble concerin tucl cle sices and whiog theat thiogeer code should contain all classes of a specific domain/context and only provide access to other packages through a smuch easit\n",
      "\n",
      "\n",
      "iter :297500, loss:0.124043\n",
      "apee cofre codests more reat imuping bould be capturing the sisill ulu neere itvery istryoglithin. Thecty snobgempore, and bou cody arat youlictiqura ies foreptleat yfic arint in ts compest, and otuth\n",
      "\n",
      "\n",
      "iter :298000, loss:0.558045\n",
      " woge boundar endeponthe ssmencess man? Nothinging learlinge. It copr pver contercercomyos mas mapy he sto insess fuchandid ount ofed ofet context impores andy.\n",
      "\n",
      "Then, instead of writ yout im orpone R\n",
      "\n",
      "\n",
      "iter :298500, loss:1.321855\n",
      "n lrable should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changefory ur chances to creata od im ingy houlic summary of the story is that things get much easier to understand and \n",
      "\n",
      "\n",
      "iter :299000, loss:1.098211\n",
      "plitedreply sther iqum thiog theas the huthes sill is orpererfrce. Yowrciot taru simrest asit ind othe thy ing bog isians toglear. botectnot yruct inow sif y hmaes the cemponentaviog th urger inew and\n",
      "\n",
      "\n",
      "iter :299500, loss:0.761799\n",
      " sist of ied ark koupdith un. It asss foreitessstha she code things get much easle doupledge itheade tha d code that sall ou h aen context from contamination and overreaching from other contexts.\n",
      "\n",
      "Wha\n",
      "\n",
      "\n",
      "iter :300000, loss:0.539308\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :300500, loss:0.397660\n",
      "T togall compes compop bomprions mounder are code taverained mape rofely.\n",
      "\n",
      "Low coupling means fewer innos to make on withives access to other packages through a unsy.\n",
      "\n",
      "The basic summary of the story i\n",
      "\n",
      "\n",
      "iter :301000, loss:0.308163\n",
      "a uugha sigh context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group the\n",
      "\n",
      "\n",
      "iter :301500, loss:0.250617\n",
      "ed meterything wray to learn compictestext ang unile ithe inte tableacsmer The decontint torether? The code that serves a common campood onep surh that.\n",
      "\n",
      "The basic summary of the story is that things \n",
      "\n",
      "\n",
      "iter :302000, loss:0.214253\n",
      "esisil bof comctions ot caplet ed ablem?on maed suapes add invery.pne esting your code as sising unly hout im on? Nothine. Use y ipe the codest, and it youthe susictings to class, and endeponredes tor\n",
      "\n",
      "\n",
      "iter :302500, loss:0.190633\n",
      "ctestobly urinde tohect, ave ass of yode theall oncod ounes components.\n",
      "\n",
      "Ideally not your acnecode iog thet codupt coupled. The resulinill as to a is thand compose, and ProductRepository are highly co\n",
      "\n",
      "\n",
      "iter :303000, loss:0.174104\n",
      "e anntest, wnould a arient your ro erorelit. \n",
      "houp arutinll test component depends on or interacts with other cofpes curvecteduting the domyonceasyou dupestsitodemasist is together, stays thaplit inla\n",
      "\n",
      "\n",
      "iter :303500, loss:0.163843\n",
      " worething wloglective dearlyr Cour acies complit.\n",
      "\n",
      "Thece, and it yout inge th urkamponents accemstonde. Use well-defined. kevel, and murh cons togessto ists code should reflect the arcomy are is comm\n",
      "\n",
      "\n",
      "iter :304000, loss:0.156133\n",
      "n puplis ing utReainn cowedu ntorlycones ongs.\n",
      "\n",
      "The bacizs sulls of yodemsaccexs forectsRepterode anconted.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies\n",
      "\n",
      "\n",
      "iter :304500, loss:0.150259\n",
      "pliteed, sto romethere compose tem that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can e\n",
      "\n",
      "\n",
      "iter :305000, loss:0.146053\n",
      " tem that cansiglr acouting chancis couplinge conead poutlycomponent. The naplesth iog o comrore anconser.\n",
      "\n",
      "The code that changessto interacts with othep tore amut inge ine tha sige the damp context i\n",
      "\n",
      "\n",
      "iter :305500, loss:0.142792\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "or even replaced witly.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decom\n",
      "\n",
      "\n",
      "iter :306000, loss:0.140225\n",
      "TThese componere easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things ge\n",
      "\n",
      "\n",
      "iter :306500, loss:0.138785\n",
      "a uund wnow components.\n",
      "\n",
      "Ideall onet and ProductRepository are highly coupled; why would not you geons ruring bogems, will end up if arining utiturkc mur if ark component dagwsyonly pone sint controcr\n",
      "\n",
      "\n",
      "iter :307000, loss:0.137360\n",
      "ed masy po understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays tog\n",
      "\n",
      "\n",
      "iter :307500, loss:0.136128\n",
      "esinn anct. The none des we roffece, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that theviong kusis ing puon th cencouplcoru irle thing unde.\n",
      "\n",
      "Then, in\n",
      "\n",
      "\n",
      "iter :308000, loss:0.135326\n",
      "ctessspereacem thy thit couplinges o them of cos on ances that the. Itowit thyounced merrerisit. Co the nhe resu nneclentice context amu sperictemlod pente, athac is enting yhoupling bof com thit your\n",
      "\n",
      "\n",
      "iter :308500, loss:0.133149\n",
      "arected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific deat torr cingle, components. It means one component can be changed or even repl\n",
      "\n",
      "\n",
      "iter :309000, loss:0.132677\n",
      " Cohe inve ale code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next im of con efull, inde arichs th a\n",
      "\n",
      "\n",
      "iter :309500, loss:0.131464\n",
      "n lrabletRed int purpose on suchand intoreland mmoflected ounden, winges once. \n",
      "hext is erterface. \n",
      "Comyoply ahating unit tests for efec averall components clearly announces their purpose, and such a \n",
      "\n",
      "\n",
      "iter :310000, loss:0.130003\n",
      "plitrer, and und uturay and unn cenderend ontext and ono understand and maintain if your architectural ideas map explicitly into the code. Your code should refle thes the. The nomesibly to Counexts.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :310500, loss:0.128965\n",
      " sista unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit todertoblit cone That oss focyopleak houp context froup in the dodull urrectund the tog\n",
      "\n",
      "\n",
      "iter :311000, loss:0.127863\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :311500, loss:0.126800\n",
      "The dampone, and dou should contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Thende thy dep cfipl dia stoul thaw undependent, and\n",
      "\n",
      "\n",
      "iter :312000, loss:0.125983\n",
      "a uund wnow and lepledentsithin. Besting youcher as toundacting y hope simply ro preffecting othes, storke uti enta sisent correcteyssim es copthoo domprarities marhe sia s component canr ping ithenge\n",
      "\n",
      "\n",
      "iter :312500, loss:0.124853\n",
      "ed make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific doma\n",
      "\n",
      "\n",
      "iter :313000, loss:0.124111\n",
      "esinn aly todall lssuntsrollacl-dele Re, arhances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why cod\n",
      "\n",
      "\n",
      "iter :313500, loss:0.123894\n",
      "y coupling. Apply the Single coderatid. The result hour pvery offer one The nometinle sowilly toher, that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public!\n",
      "\n",
      "\n",
      "iter :314000, loss:0.122427\n",
      "atees che basis sull cobu enderstood it antererinither store is cose ithe code that code and mever ath components, these components will inevitably interact with one anoese ithe defent during duct.\n",
      "g \n",
      "\n",
      "\n",
      "iter :314500, loss:0.122614\n",
      " rogethoun the component concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctleass interface, covering every behaviour of the unit. Check\n",
      "\n",
      "\n",
      "iter :315000, loss:0.122065\n",
      "n duplsucommerother contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and Product\n",
      "\n",
      "\n",
      "iter :315500, loss:0.121230\n",
      "pliteed for evers anterestyones componenteas of ine rall coupling ontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothin\n",
      "\n",
      "\n",
      "iter :316000, loss:0.120739\n",
      "s ences th ifore ant thevis ople inver components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a sy\n",
      "\n",
      "\n",
      "iter :316500, loss:0.120166\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller compos components.\n",
      "\n",
      "Idealind oounde components, these components will inevitably intext ing urlicon sucti\n",
      "\n",
      "\n",
      "iter :317000, loss:0.119536\n",
      "Textne. The nade ssummargepsialr contere ingy to learlyrabl gesising isit to to stouness, suplicem thal dexthin. llot macle, mapy of thatsi\n",
      "gem? nt the arc inges to are smatig I ur aveli istes ferk th\n",
      "\n",
      "\n",
      "iter :317500, loss:0.119152\n",
      "a urgar pl nop shaw.\n",
      "\n",
      "\n",
      "Whawid ofur, ald urabrext mpone the temptation to enouns fuch und component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "\n",
      "iter :318000, loss:0.118395\n",
      "ed matievi smurkace. shays of corperycsing fremaciss masiend purlit couba decthod of erkr contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different prob\n",
      "\n",
      "\n",
      "iter :318500, loss:0.117980\n",
      "esis of canoss ane, and I ho ensestodka enity ge cory sumpothone ssms.\n",
      "\n",
      "Iterientests fectibllyo howssog ondes the domala be control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across \n",
      "\n",
      "\n",
      "iter :319000, loss:0.118086\n",
      "ctestople Single lespora efiy code thyourher shace compose tory cimpund pontain and pong of cing ot contexts fof corres che tive todewing inly weing unkally conithes th ivit if ark amuctis other Couro\n",
      "\n",
      "\n",
      "iter :319500, loss:0.116886\n",
      "a enterface readite reptith oo theas surlrcouplainze the the oree onder ontero thous turves of cleall urcess, sadily delr for ever ofercodew y avent th we inereacem daply arcour of cou pom rha ing.\n",
      "\n",
      "T\n",
      "\n",
      "\n",
      "iter :320000, loss:0.117310\n",
      " wobl couthing we nears fereaces shais wogethy pemponents, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result\n",
      "\n",
      "\n",
      "iter :320500, loss:0.116958\n",
      "s abit thiogethemtour te tasito etocting othes component depends on or interacts withit of unde, mofrout arr concendrial corres ences together, carsig beveructhes thes of boullinges s wint ProductRepo\n",
      "\n",
      "\n",
      "iter :321000, loss:0.116339\n",
      "plitledore tomethes components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and lowe sinve stomping tha s components. It wite, that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to und\n",
      "\n",
      "\n",
      "iter :321500, loss:0.116008\n",
      " concodt torwling be ro enge chig your cortext Prill is componctyry.\n",
      "\n",
      "Comy. B.\n",
      "\n",
      "Thene chaves rurp control for lic! Thay or eryourd thems.\n",
      "\n",
      "The esur. Cohe bane in text and ounot things get much t you n\n",
      "\n",
      "\n",
      "iter :322000, loss:0.115603\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :322500, loss:0.115102\n",
      "T together?\n",
      "lI we ing to plit code and ino pests and Ba ain yos and much thatigg Ba stacs fewer for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component c\n",
      "\n",
      "\n",
      "iter :323000, loss:0.114853\n",
      "a uunt dur. The napkagiog the athe con h acluclly Simuog dem?onle coupled; wha is te inoulled accthes the Single Responsibinity conening ll tn a i gunlede thy sed thin simgro leak the domain. The resu\n",
      "\n",
      "\n",
      "iter :323500, loss:0.114238\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ed make everyode thote correctly. Packages should contain all classes abied to make everything public! That is why codebases turn into and ot your cor evenally.\n",
      "\n",
      "Then, instead of writing unit tests fo\n",
      "\n",
      "\n",
      "iter :324000, loss:0.113904\n",
      "esinn alither tugessems canmadare ted ablem? Cohesion.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries durin\n",
      "\n",
      "\n",
      "iter :324500, loss:0.114141\n",
      "ctesss Copubit ba he bounded aer corsigh yout code isingly are is enting your code as beginneld and condect, and oncom rhoun ark orequange chig I oupt orealet efronetorseapempe areffecricter thet codu\n",
      "\n",
      "\n",
      "iter :325000, loss:0.113032\n",
      "a etsemplethais te und root ta ka enterconser interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When softearerinn wewing C\n",
      "\n",
      "\n",
      "iter :325500, loss:0.113560\n",
      " wobl cout aruponent's moresis wore reatryor.\n",
      "g.\n",
      "\n",
      "The che smar eve are uacemarit tompos cout imull cout ingy are is dit much easind objects.\n",
      "\n",
      "IteraintesRes of we for over contexts.\n",
      "\n",
      "The basic summary \n",
      "\n",
      "\n",
      "iter :326000, loss:0.113285\n",
      "line dh undectural ideas maple. gh with coupling lle ate cofreacone newe isseroret. Ptothe saal comm.\n",
      "\n",
      "Low th o juclly pould conieve ale suche hour codupt, woprevedy anterkound ie y hode component dep\n",
      "\n",
      "\n",
      "iter :326500, loss:0.112806\n",
      "plityBnton. Tha s fouthed to steall necosit paen sicum thy supling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coup\n",
      "\n",
      "\n",
      "iter :327000, loss:0.112565\n",
      " concodt, andess.\n",
      "\n",
      "Itays together. The anc iver rill inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists o\n",
      "\n",
      "\n",
      "iter :327500, loss:0.112286\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposedy of eucins would be capturentibly interact with one another, and it will require clearly defined boundaries not to lea\n",
      "\n",
      "\n",
      "iter :328000, loss:0.111894\n",
      "Textnowly packa youplad The resple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to ly ura interfaces and inversion of control for low coupling.\n",
      "\n",
      "L\n",
      "\n",
      "\n",
      "iter :328500, loss:0.111751\n",
      "a uh component conce taught you.\n",
      "\n",
      "By now, you sumponzeas map expllicon ef offarring yode. ghe ro urkesine sses s with othes of every class, write unit tests focusing on the component's public interfac\n",
      "\n",
      "\n",
      "iter :329000, loss:0.114136\n",
      "ed maties inte elit. Both address for every public methin yontaon conesillze comrost, and ances to clatict Basitoreer foupes cuctede, annterstand and maintain if your archings get mact mall on e compo\n",
      "\n",
      "\n",
      "iter :329500, loss:0.875610\n",
      "esitgit of couc and overreanesse nofronkaly componentsieli- tuct your asit tests ayceit commongprefle thagro inent's wur averain testext on com corperyon dopenes te th unce cout mode and protectithit.\n",
      "\n",
      "\n",
      "iter :330000, loss:0.830593\n",
      "cte tompotecan ty he codg that ss ans lout im ont ay urdithy pleplinea ic supliceer ancode conceat to orharill areale (SRP) on im eng onge composedtinve ulitle ances to clatsi\n",
      "\n",
      "It, ar. ka er in encons\n",
      "\n",
      "\n",
      "iter :330500, loss:0.648561\n",
      "apees componenatisit things onte cevery packauctseatestinn le on tay siges eve ara easy to ensser. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope\n",
      "\n",
      "\n",
      "iter :331000, loss:0.474253\n",
      " wobl cout wing fourates sur in thendillacting other poupkedrepo is artesu ntey ons let much maon conesing urituct ann context amu storsiogmpos to lewet thing ysurle bound reasing ok ghouplither masit\n",
      "\n",
      "\n",
      "iter :331500, loss:0.352718\n",
      "n encapsudd oraisif yonent's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand \n",
      "\n",
      "\n",
      "iter :332000, loss:0.273834\n",
      "pliteede storyodetheplaceererfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across enceplans oble wia d avell could codti\n",
      "\n",
      "The chaes to understand and main\n",
      "\n",
      "\n",
      "iter :332500, loss:0.223597\n",
      " ses aund and unces to clatsithit interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even repl\n",
      "\n",
      "\n",
      "iter :333000, loss:0.190999\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :333500, loss:0.169689\n",
      "T together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptatio\n",
      "\n",
      "\n",
      "iter :334000, loss:0.155384\n",
      "a urear plinner code that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essenti\n",
      "\n",
      "\n",
      "iter :334500, loss:0.145303\n",
      "ed public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specifill coure that will end\n",
      "\n",
      "\n",
      "iter :335000, loss:0.138095\n",
      "esily accergle gege tha sic your aro cencessersterysibge stompodedasid be accone tsstobleay fingse Bothy components che urs code theaces of yows.\n",
      "\n",
      "Low coupling means fewer intopl mad boupknenenean er \n",
      "\n",
      "\n",
      "iter :335500, loss:0.133639\n",
      "ctestopued code prefrit wo ieverurstests freducterts compone esuchanges commonethot cfed context froupling. Apply the Single Reprompotesion anc encomy thit and Iudit macling fout thy pempiced ances th\n",
      "\n",
      "\n",
      "iter :336000, loss:0.129181\n",
      "a erays to w anderacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces\n",
      "\n",
      "\n",
      "iter :336500, loss:0.127584\n",
      " rorengrothe shoun accontt Botewy and maintain if your aro of er in pose ass dupuncing yourcoryes coppesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restrict\n",
      "\n",
      "\n",
      "iter :337000, loss:0.125555\n",
      "n muctRestestoblladitill gepked ba unt horothe houpder, deatRew, purpess of youthe sion cou che to mablew iod ot ercof cam ball , plindeptssentry weterpery,y.\n",
      "\n",
      "Then, do armaed interface, covering ever\n",
      "\n",
      "\n",
      "iter :337500, loss:0.123997\n",
      "pliteederfaissing. .u how is mmuthitg wit murg tly. ed why pout, cohesiog th ackests fuc iver code all areatifrres ouplin. Use wal your pone component's public interface, covering every behaviour of t\n",
      "\n",
      "\n",
      "iter :338000, loss:0.122760\n",
      " inow ancem that things get much easies to understand and maintain if we can effectively draw and enforce boundaries during deveaple itherropued we have is enting gemponenteratryou hang I hoped onceri\n",
      "\n",
      "\n",
      "iter :338500, loss:0.121572\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require co tomProbp i\n",
      "\n",
      "\n",
      "iter :339000, loss:0.120583\n",
      "TReprerkauld context wn o ompone fry corpess thy code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common p\n",
      "\n",
      "\n",
      "iter :339500, loss:0.119569\n",
      "a uund wnew cofpes chin suak urconcectamaon cos rog che thar echine rall hehesRepositogeting lsur code and protecting that knowledge in your context from contamination and overreaching from other cont\n",
      "\n",
      "\n",
      "iter :340000, loss:0.118935\n",
      "ed puple is access of iner corieve er coplect, Prodectho e he the code that changes the Single Responsibility Princing is or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :340500, loss:0.117905\n",
      "cergstowy hode y urpunde to tog couply.\n",
      "\n",
      "The montext and ouleak the codeling lsur code and protect with one anceferpos macumetorke things onde thit contectster interconnections across components. It m\n",
      "\n",
      "\n",
      "iter :341000, loss:0.118229\n",
      "ce iant, and suche gow chings orpergrow compon.\n",
      "\n",
      "The mount banlend conceg thes thin stog the code. Yowuccing coh s.\n",
      "\n",
      "Ideall of ever interfaces aud in ther, cade component's public interface, covering \n",
      "\n",
      "\n",
      "iter :341500, loss:0.116994\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a erasser.\n",
      "\n",
      "Therer sia sim ingroundacizel of couce that that dow. The nepender, routith obitryould bo ner, theveris ing the sisict your co nterfaces and iannec muthing pone ur. h aentsionderact, are t\n",
      "\n",
      "\n",
      "iter :342000, loss:0.116819\n",
      " ro enactswer inceplated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that is wit your to leare coveddiagyoundably ubig tests fecomrost, prnone bo cema\n",
      "\n",
      "\n",
      "iter :342500, loss:0.115569\n",
      "n prould yourectss.\n",
      "\n",
      "Ideplricle nos ros consibld wacee chig madi simsigh context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common\n",
      "\n",
      "\n",
      "iter :343000, loss:0.114520\n",
      "pliteeder thead taxe sssmstaes in weat ino pests ho bos compout the domain. The nestlin mefiln ic sumpother components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Res\n",
      "\n",
      "\n",
      "iter :343500, loss:0.113646\n",
      "d interfaces and iannects and conent turitithwy theceddwit prewlacees of every class, write unit tests focusin/context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductReposito\n",
      "\n",
      "\n",
      "iter :344000, loss:0.112830\n",
      "or even replaced wit cour ponte tod oblemyou ha demss cimh contery uruqued component dawing on the component's public interfaced.\n",
      "\n",
      "It youndariigle sucinces together, stewit coupling he tompone trer co\n",
      "\n",
      "\n",
      "iter :344500, loss:0.112090\n",
      "TRewit to eraary cons or wer components, theses omponede codg that y urlyoblays wled inguply Reprifle ie stayllound andodeacen tablu, ioge suring on the story is that things get much easier to underst\n",
      "\n",
      "\n",
      "iter :345000, loss:0.111461\n",
      "all foflect\n",
      "\n",
      "The abotessems, ane ssefropreacyspone starit po thaul th urgall conienes to mame teat sests foundeptext init to learn composed intoray amur component you derentive theckout my article abo\n",
      "\n",
      "\n",
      "iter :345500, loss:0.110771\n",
      "wdergeping lfoglith other cores onthe froth to lecried wing he component ead prevectinne ithe foved objects.\n",
      "\n",
      "It's essell-dallincrosin snau ofdering gegled; why one isians r pain if your archic mainta\n",
      "\n",
      "\n",
      "iter :346000, loss:0.110095\n",
      "esind objects.\n",
      "\n",
      "It's ervingr enstare is conted thwiog the ghound er iace cout how much on to prereade thewything wiy icomr arce poup architectural ideas map explicitly into the code. Your code should \n",
      "\n",
      "\n",
      "iter :346500, loss:0.110311\n",
      "wer of e archic main/context and only provide access to other packages thro ghe th ra ve are smuth es that thal and intiting unit tests for every public method of every class, write unit tests focusin\n",
      "\n",
      "\n",
      "iter :347000, loss:0.109005\n",
      "apes sha ioveracts webith d fewer interconnections across components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use\n",
      "\n",
      "\n",
      "iter :347500, loss:0.109501\n",
      " invery thysion mes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to re\n",
      "\n",
      "\n",
      "iter :348000, loss:0.109003\n",
      "n puplis ing bleation to make couplinge nnterface hout ioupled. Pended, and lotha she codain koundewit tadl of o expriclinges s components.\n",
      "\n",
      "Ideally nothe tha d surhes of e hes os anctes, ances to cre\n",
      "\n",
      "\n",
      "iter :348500, loss:0.108590\n",
      "plcess, write unit touply.\n",
      "\n",
      "The, wobieve are suche houlit indalling mra siag ons derrowly.\n",
      "\n",
      "Then, instle. thasly defropresis suritly Reptive testoun he ba k hents.\n",
      "\n",
      "Id consay sear pur chasines esurcom\n",
      "\n",
      "\n",
      "iter :349000, loss:0.108238\n",
      " sisto tougher context froupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully erind overrow the domain. The result is a system that consists of co\n",
      "\n",
      "\n",
      "iter :349500, loss:0.107897\n",
      "or even replaced win thewituyking mat if o uph cors that you dray ponode ioversess bounes. Thom the code that your cohet contectisistadr isit. Chom oftititode coderats to understand and maintain if yo\n",
      "\n",
      "\n",
      "iter :350000, loss:0.107516\n",
      "T togetising unis le sichicg of sngef arroul archit commonep ive utu smconed poput in wepingels fow che tha forewer for high cohesion. Use well-defined interfaces and inversion of control for low coup\n",
      "\n",
      "\n",
      "iter :350500, loss:0.107232\n",
      "a uugha sing of cing your code and proterkigres components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller compone\n",
      "\n",
      "\n",
      "iter :351000, loss:0.106840\n",
      "ed public! That imste, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted y\n",
      "\n",
      "\n",
      "iter :351500, loss:0.106407\n",
      "rald components onces th cohes that conthy texts.\n",
      "\n",
      "What duassmang the Singl-delicour components cof ined boundaries not to leak the domain. The result is a system that consists of cooperating but inde\n",
      "\n",
      "\n",
      "iter :352000, loss:0.106861\n",
      "ctessiovering on the component's public interface, covering every behaviour of the unit. Checkout my arthings code ene. revene ssmon? dhos anr the es entara ulit. Both aconeer fore cod ino coore ane i\n",
      "\n",
      "\n",
      "iter :352500, loss:0.105750\n",
      "anesse theplycone domar ind low coupling. Apply the Single Responsibility Priny aches of in ed mare reatr once context from contamination and overreachesswinly th arcomponents lhally.\n",
      "\n",
      "Low couplis. Th\n",
      "\n",
      "\n",
      "iter :353000, loss:0.106447\n",
      " wond pont or in are invery.ple hemeother compon ra umporenta unces that yss.\n",
      "\n",
      "Ideas torwicigh com oresing yevict, surres compont ball geugethand caane evict, Prompone hemalit incesstowit in wit wicor\n",
      "\n",
      "\n",
      "iter :353500, loss:0.106153\n",
      "n dupls such ark he the code teatively wready thha, thit ing ysteratedothd wigh cone corpesgragcting le athyoges wile anges common omak the gempos machess conce tout code is ohit coupled. Papk fom com\n",
      "\n",
      "\n",
      "iter :354000, loss:0.105928\n",
      "pliteedtodrepo ieverrealepr overnot the cent contextsing leur access to of concept, and atcom to inende, and surh muncendilly (Sim thaw cthes to ender?\n",
      "gve undes that the thy ses edeap ithe cofadinsio\n",
      "\n",
      "\n",
      "iter :354500, loss:0.105784\n",
      " semlrinve de caple the rout im oching fevict da ro entarkaly compontntanle tu ncecther to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, \n",
      "\n",
      "\n",
      "iter :355000, loss:0.105630\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :355500, loss:0.105465\n",
      "Texts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaple ithe rofuctlealy componepts.\n",
      "\n",
      "Ideally\n",
      "\n",
      "\n",
      "iter :356000, loss:0.105384\n",
      "a iogy th thesion ande thou dtpent', wurint coody anderent durt change component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Si\n",
      "\n",
      "\n",
      "iter :356500, loss:0.105239\n",
      "winder arutinl decomros dourgem ho ehoup coupling be is antext ing urlice, and ProductRepository aready thgopkemwectes, tublis ing puble yss.\n",
      "\n",
      "Ide component ran be changed or even replacen effective t\n",
      "\n",
      "\n",
      "iter :357000, loss:0.105008\n",
      "cergs ofto leak tings gethinge writo code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important t\n",
      "\n",
      "\n",
      "iter :357500, loss:0.105730\n",
      "co s mary pemeant re thauly ancomy thit. Checkout my article aboulle cory of the code th arkally, code on. gher of ing.\n",
      "\n",
      "The pomponent's forecinge snes of gver interface, covering every behaviour of t\n",
      "\n",
      "\n",
      "iter :358000, loss:0.104815\n",
      "a erasser. couplily acsesthing ur ine ffep ive uritinls to edessint ind obje tupls fom correstexting the componend depends on or interacts with other components.\n",
      "\n",
      "Ideallyonether compont, an commeron s\n",
      "\n",
      "\n",
      "iter :358500, loss:0.105801\n",
      " ro enine raly that.\n",
      "\n",
      "The basictesuss unto inounteriog hemactmeanint es tncuns und on coray will enit. Coure can effectively draw together tour theari if y hout he th he next anc mera muctRepositore t\n",
      "\n",
      "\n",
      "iter :359000, loss:0.105773\n",
      "n duplsus.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if rod ha, ? hope cou duracting other components.\n",
      "\n",
      "When software is decomposed into smaller compone\n",
      "\n",
      "\n",
      "iter :359500, loss:0.105790\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ples andyos once thate ie argesitvercess fecomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the \n",
      "\n",
      "\n",
      "iter :360000, loss:0.105930\n",
      " concode torethe, conterother codeatRer orien s secimhethed objects.\n",
      "\n",
      "Iterainterstand and inteplapnes compont, and cturinizl areas ony douplind lew is muthersinery on wectext froty in to wreato etowrc\n",
      "\n",
      "\n",
      "iter :360500, loss:0.106005\n",
      "or even replaced without impacting other component dep ither?\n",
      "Prodbing luritvisill contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effecti\n",
      "\n",
      "\n",
      "iter :361000, loss:0.106123\n",
      "TReptiog one corpes? Chomponntacsit the codelitha shes anlasting them togetisig the chabit iaver components, these components.\n",
      "\n",
      "efrarict Thats all compose Prout int gounder arpesing bo smaen the undor\n",
      "\n",
      "\n",
      "iter :361500, loss:0.106302\n",
      "a uught poun aentsis ofry ofher coppesiod ake repte simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing Thays components.\n",
      "\n",
      "When software is decomposed into\n",
      "\n",
      "\n",
      "iter :362000, loss:0.106455\n",
      "ed maty sha cha cofuct bound of yode arvery impore thes togetising edith ro leffectively draw and enforce boundaries during deveassollyounesiog thes,osta ie ams ha deation to arkevide access to other \n",
      "\n",
      "\n",
      "iter :362500, loss:0.106431\n",
      "es.\n",
      "\n",
      "Ideall on pled orheve is aly he es ovedy phesith o campome, anlyogr it caprering ont ra cohaccest(\n",
      "\n",
      "Werke ithe archatesdopleraces thyogriple tr wecundes together, care ither?\n",
      "\n",
      "The posucss Product\n",
      "\n",
      "\n",
      "iter :363000, loss:0.245510\n",
      "ctesketucaples edge nnhere compos cout imuticis and maintices ges oble torply pave is edting maunesicles es of can effecting Baskes of tige tapilly urithero inent's ether tour po profurfacer.\n",
      "\n",
      "We need\n",
      "\n",
      "\n",
      "iter :363500, loss:2.773999\n",
      "e bos components. It means one component can be changed or even replaced without impactive ts the fomponents.\n",
      "\n",
      "Idepes onces tn iver reptleall one contain alnecessary dependencies thay tupk gemt, whe c\n",
      "\n",
      "\n",
      "iter :364000, loss:2.989042\n",
      " wobldwing brodecthor overy anysRes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewe inse. Yovedindradd componeng onctu fode and context and onded.\n",
      "\n",
      "The mopulle and c\n",
      "\n",
      "\n",
      "iter :364500, loss:2.202937\n",
      "n thancis sut yod muchle component can be changed on the component's public interface, coverforn centing your code as yode is ange componed interercone kunk fovected on the component's publice coupuct\n",
      "\n",
      "\n",
      "iter :365000, loss:1.521500\n",
      "pentsieptide them to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together\n",
      "\n",
      "\n",
      "iter :365500, loss:1.019113\n",
      " is cound bof taylan. I orpere fout.\n",
      "\n",
      "The andemstot. blainging luyit im mutive to the next important thing you need to learn correctly. It is about how much one component depends on or interacts with \n",
      "\n",
      "\n",
      "iter :366000, loss:0.695257\n",
      "oble ine rably shes to are are compose hanged for how overy behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand an\n",
      "\n",
      "\n",
      "iter :366500, loss:0.492262\n",
      "T to clefry, context wibit coure componende, maky Componcteracts mas one hespled. \n",
      "Lha ed oh componentsseracsesseboed to learn correctly. It is abneces contexts.\n",
      "\n",
      "What do ProductRepository and BasketR\n",
      "\n",
      "\n",
      "iter :367000, loss:0.365646\n",
      "agle the components clearly announces their purpose, and such pente, mound with onorkenllit wollinges tn context ins us components.\n",
      "\n",
      "Ideally, we should aim for high cohesion ang the Single Responsibil\n",
      "\n",
      "\n",
      "iter :367500, loss:0.285218\n",
      "ed make erable sicould thate in encansing meflyctndinge ssable sucresist torcorsin ing public! That is why codebated thevit howioge sstoreat yould context from contamination and overreaching from othe\n",
      "\n",
      "\n",
      "iter :368000, loss:0.234297\n",
      "esiss alg that thing ghomulitlicsit, ProductRPpogro sill uog ully. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to lea\n",
      "\n",
      "\n",
      "iter :368500, loss:0.202042\n",
      "cexis.\n",
      "\n",
      "The compling lurgefor thes component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aimp inte. s wild if arkpole smmponestryoucthe temptitl-definde cippeying onge coverint \n",
      "\n",
      "\n",
      "iter :369000, loss:0.179760\n",
      "a eraskendent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaprefones.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :369500, loss:0.166635\n",
      " koveduriting but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve\n",
      "\n",
      "\n",
      "iter :370000, loss:0.157008\n",
      "s able would not you group ing ulllion ms to mainesseroore rfawlgit hou durestans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary depe\n",
      "\n",
      "\n",
      "iter :370500, loss:0.151527\n",
      "plite, th wiot end.\n",
      "\n",
      "We nece somuthed objects.\n",
      "\n",
      "Run much more readable. The name of such components clearly announces their purp cencous ave and Bated.\n",
      "\n",
      "The more restricted your access level, the fewe\n",
      "\n",
      "\n",
      "iter :371000, loss:0.163640\n",
      "d offereas maple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with \n",
      "\n",
      "\n",
      "iter :371500, loss:0.173079\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is dr onges together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewes dill ing means one c\n",
      "\n",
      "\n",
      "iter :372000, loss:0.160797\n",
      "T together?\n",
      "Produc. The nane tohetrereflect, Prodully.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries durin\n",
      "\n",
      "\n",
      "iter :372500, loss:0.151439\n",
      "a uh codewied oble wia d be the none des, chatly.\n",
      "The rofer oncepto s acsess bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintaincis stow the com\n",
      "\n",
      "\n",
      "iter :373000, loss:0.144033\n",
      "ed make er if yodr components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists o\n",
      "\n",
      "\n",
      "iter :373500, loss:0.138665\n",
      "ctien to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays toget\n",
      "\n",
      "\n",
      "iter :374000, loss:0.135385\n",
      "y.\n",
      "\n",
      "Coupling is the nher shat. \n",
      "Coupling lesteresias mas one story is thessin le componende, mpkarled arcempontiblevecontery urh context from contamination and overreaching from other contexts.\n",
      "\n",
      "What \n",
      "\n",
      "\n",
      "iter :374500, loss:0.131720\n",
      "ated.\n",
      "\n",
      "The gesuble component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understan\n",
      "\n",
      "\n",
      "iter :375000, loss:0.130676\n",
      " ioveracts with acsiogy to onderatid.\n",
      "\n",
      "Theedd anange is ont areer of theviting couplinne.\n",
      "\n",
      "Itursioge ia wecthy. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideal\n",
      "\n",
      "\n",
      "iter :375500, loss:0.128817\n",
      "n dupls annted thwiog thatresss.\n",
      "\n",
      "The couplit code ass in entsithit of e hace ceand and maintain if we can effectively draw inte sicem thy todreplated.\n",
      "\n",
      "The more restricted your access level, the fewe\n",
      "\n",
      "\n",
      "iter :376000, loss:0.127229\n",
      "pliteed contr.\n",
      "\n",
      "Coxthore that will ind ineflyctndarill anderacks on comptive tsstopithary of the story is that things get much easier to understand and maintain if your architectural ideas map explici\n",
      "\n",
      "\n",
      "iter :376500, loss:0.126059\n",
      " ses susicondeplars of thatsi\n",
      "ge you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with othe\n",
      "\n",
      "\n",
      "iter :377000, loss:0.124824\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require cleand ovires\n",
      "\n",
      "\n",
      "iter :377500, loss:0.123850\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Textsinle tu are surhe ung.\n",
      "\n",
      "The pomponent's public interface, complinn compor mavu be ass aring urith is cef acreres ant reweasser tha ercoute for high cohesion and low coupling. Apply the Single Res\n",
      "\n",
      "\n",
      "iter :378000, loss:0.122898\n",
      "a upcenderathit and maintain if we can iffecthe domain im onitoreer forpesecysi\n",
      "ge would be capturing that thing y coulize todilit that che unnes together, carefully encapsulated.\n",
      "\n",
      "The more restricted\n",
      "\n",
      "\n",
      "iter :378500, loss:0.121965\n",
      "ed maty Coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create un\n",
      "\n",
      "\n",
      "iter :379000, loss:0.120918\n",
      "esiss ang on mere refer annects once th for every publices an that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion as ess.\n",
      "\n",
      "Ide\n",
      "\n",
      "\n",
      "iter :379500, loss:0.120909\n",
      "consint contaid innes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to \n",
      "\n",
      "\n",
      "iter :380000, loss:0.119166\n",
      "ated.\n",
      "\n",
      "The more restricted your access licem thy urkakethever pecour ha Shice, and ProductReposicter, youply would context from contamination and overreachings gom ongvecting your code ast is anse sta\n",
      "\n",
      "\n",
      "iter :380500, loss:0.119514\n",
      " wore anur sthes?\n",
      "g.\n",
      "\n",
      "The basic summary togesisiog of one code that code and winn sentsientict th our porperent.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and mainta\n",
      "\n",
      "\n",
      "iter :381000, loss:0.118707\n",
      "n tuwnciss compone thy unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clea\n",
      "\n",
      "\n",
      "iter :381500, loss:0.117900\n",
      "plites ereblaines to understand and maintain if we can effectively draw and enforce boundaries during deve isvenns ray ses bothesstr contery a ingebain mes tog covela icheractedtobjteer ore ctadd Appl\n",
      "\n",
      "\n",
      "iter :382000, loss:0.117351\n",
      " ia suth in comulinl-dectme. \n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaprefocemroneptspont\n",
      "\n",
      "\n",
      "iter :382500, loss:0.116635\n",
      "or even replaced without impacting other component dep iveresinl-et bowy comcod oundede ande the gether. Cohesion isto th unces th ce rolly.\n",
      "\n",
      "Coupling luyg pline nouple inverystnes turf carkatins thag\n",
      "\n",
      "\n",
      "iter :383000, loss:0.116030\n",
      "Textsinnt to they the Single lecunticled or to leak the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common pupticonsing m aare is a sysg\n",
      "\n",
      "\n",
      "iter :383500, loss:0.115483\n",
      "asions ou th context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, wriog thecoms to understand and \n",
      "\n",
      "\n",
      "iter :384000, loss:0.114884\n",
      "ed make everves a cungqump inded tar. The namr cortext impontsigl th the urne dode aing ogever, rry.\n",
      "\n",
      "Coupling lectiglg ound wnowitict your changes together, stays together, carefully encapsulated.\n",
      "\n",
      "T\n",
      "\n",
      "\n",
      "iter :384500, loss:0.114169\n",
      "ctien to iner to sterfaces component depends on or interacts with othe tha illes, ro are cors obje the temptation to make everything public! That is why codebases turn into a mass of interconnected ob\n",
      "\n",
      "\n",
      "iter :385000, loss:0.114412\n",
      "ithed to amkally ieveratr coduct and uturing ysurkang ra make heplinging\n",
      "\n",
      "Componers coduptly softonle.\n",
      "\n",
      "Ther concend or inders cor them? Cohesion - the code that changes the domain knowledge in workin\n",
      "\n",
      "\n",
      "iter :385500, loss:0.112968\n",
      "a erasserstoule Shhing umke reatabie wesing ont xthe grow of a iple (SRP) ances to cleare iboly, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a si\n",
      "\n",
      "\n",
      "iter :386000, loss:0.113495\n",
      " ro enatssorlederwath ungeg that knowledge if yramstays togetisss once is components.\n",
      "\n",
      "Ideally, wais a speat ef innt wlyounder are code that serves ro mtorkounecone, andes to creyk, write hackauctsew \n",
      "\n",
      "\n",
      "iter :386500, loss:0.113012\n",
      "n ditill-defined boundaries not to leak the domain. The result is a system that consists of cooperating buth fout win - the code that changes the gom orgver contexts.\n",
      "\n",
      "Then, instead of writing unit te\n",
      "\n",
      "\n",
      "iter :387000, loss:0.112368\n",
      "pleditser. Cohesion is a pretty sif inderfacinces to are simurabis ans, writexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group\n",
      "\n",
      "\n",
      "iter :387500, loss:0.112053\n",
      " serysing main if y hout im orgefuru ledf che cods, bode thy urkag.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacti\n",
      "\n",
      "\n",
      "iter :388000, loss:0.111554\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :388500, loss:0.111162\n",
      "T together?\n",
      "Produc, the architecres.\n",
      "\n",
      "The code that endeponde. shave learn muonthoro thoules shour thoun theng. The rackageses rurliches onect, wronctien to be realedent accedg your code as beginners \n",
      "\n",
      "\n",
      "iter :389000, loss:0.110885\n",
      "all of mada eraisig I fom ishe componed intarercomponents.\n",
      "\n",
      "When software is decomposed into smaller components, thatlyogyour code and in antexProlios es that knowledge in y umled ofed acosy acling th\n",
      "\n",
      "\n",
      "iter :389500, loss:0.110612\n",
      "ed mespong.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into s\n",
      "\n",
      "\n",
      "iter :390000, loss:0.110227\n",
      "es end po rhaveryopleak  achiner ablly woul ponenderpode the code that thing ysurking other contain all classes of a specific domain/context ang kouc modery make semstacing lurg fout todup if your abl\n",
      "\n",
      "\n",
      "iter :390500, loss:0.110861\n",
      "it im od wot yourdecceppur thew coflect, mapu reat tewr-che toon the uthenges th ully.\n",
      "\n",
      "The caplly ersint inces ofrrit concer he arching om of ing. Apeng the restreponthe surind rofted cthe Single Res\n",
      "\n",
      "\n",
      "iter :391000, loss:0.109929\n",
      "aced durathe. rompos ouplit ro apkage ha roge rimp components clearly annoget commoncis a le asias map exend, and condrraly hogeris weping levet, aring of casse stays together.ply ho maky coup in thet\n",
      "\n",
      "\n",
      "iter :391500, loss:0.111074\n",
      " woblecturasks of sich context inded sige the nodeasisss !ogengeare int, dedesponents, these components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact\n",
      "\n",
      "\n",
      "iter :392000, loss:0.111847\n",
      "n ditict moperatidg bage if yod of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctlyour to smeving Bastext ysher?\n",
      "\n",
      "Ideplle coducing og wey softonle.\n",
      "\n",
      "Texts to understand and \n",
      "\n",
      "\n",
      "iter :392500, loss:0.112548\n",
      "pents.\n",
      "\n",
      "It's essential to oh w. Apong or ererorued couplit th thacto mery of thever rvery omation to are isstyotRextstrofif yr?cke isne th io co thati\n",
      "\n",
      "zempont, aniclere. Yogrorcodges components. It w\n",
      "\n",
      "\n",
      "iter :393000, loss:0.358389\n",
      " semarges rofundederatinnt ono cory of the componender, inot thing you need to learn coupderkctive tout code ass is entersif arsto your to or everasind rout the ithe cing youg to erasu he heve im orge\n",
      "\n",
      "\n",
      "iter :393500, loss:1.551980\n",
      "or even replaced without impacting other componed interface.\n",
      "\n",
      "Then, instead of writing usitlyostays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewerict public! Thay \n",
      "\n",
      "\n",
      "iter :394000, loss:1.577444\n",
      "Cy.\n",
      "\n",
      "The pomponenessant contexts.\n",
      "\n",
      "Weatr wecomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the \n",
      "\n",
      "\n",
      "iter :394500, loss:1.137087\n",
      "anl of madd pononderal ther andesss cha s mhit things aldiogrepall couchanges together, stays together, cara urique intercon? of codeetsinges tn correctly. Packages shoule code ifry have in common? No\n",
      "\n",
      "\n",
      "iter :395000, loss:0.797660\n",
      "ed make everything public! That is why codebases turn into a mass of interain and code acrests focus and whiog theas tes sige nabris a s. ge herenge components.\n",
      "\n",
      "When sof coded thing your code as begi\n",
      "\n",
      "\n",
      "iter :395500, loss:0.563100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "der into smally into the component's suct, Pfopuntr pounat tests shes th inos to und por cemaone component's mur components clearly announces their purpose, and such a unit do justether. Cohesion is a\n",
      "\n",
      "\n",
      "iter :396000, loss:0.414913\n",
      "ctess to are covect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The mor\n",
      "\n",
      "\n",
      "iter :396500, loss:0.319651\n",
      "anes edilly.\n",
      "\n",
      "The code are code te codt argemurk gemptation to make ofod couplinge in togh context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketReposit\n",
      "\n",
      "\n",
      "iter :397000, loss:0.264042\n",
      " porricid your aro cory of thever sverrcontext and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every buplic methy urkabes aul, thate. the\n",
      "\n",
      "\n",
      "iter :397500, loss:0.243052\n",
      "d to ple codgesist wit codreplat or componed atnop ted.\n",
      "\n",
      "Ite corpes contexts.\n",
      "\n",
      "Whac od ingesty.\n",
      "\n",
      "Idepllcom oup thew components.\n",
      "\n",
      "Ideally, we should aimp svesing unit tects the chans cout im oft. Bover\n",
      "\n",
      "\n",
      "iter :398000, loss:0.317541\n",
      "pliterster, and intine, interface, chle inhe arr components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The rape\n",
      "\n",
      "\n",
      "iter :398500, loss:0.340072\n",
      " dempos dout im orgothes ont. Pacrusing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepo\n",
      "\n",
      "\n",
      "iter :399000, loss:0.280533\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :399500, loss:0.243552\n",
      "The dampomeracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion thessin erially pade components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitabl\n",
      "\n",
      "\n",
      "iter :400000, loss:0.210914\n",
      "alled; why poupled. Pachat things getithe hever intectle story is that things get much easier to understand and maintain ive ithem tha durobieve arkesis the codentsplly codebases turn intosither?\n",
      "Pra \n",
      "\n",
      "\n",
      "iter :400500, loss:0.190307\n",
      "ed maty of thentesurptet, cther cofullectndwite thagriqtebit impund. Both actunt dur. pengumpther complit. Bhowly code codgethine pamp ss on teryound and overreaching from other contexts.\n",
      "\n",
      "What do Pro\n",
      "\n",
      "\n",
      "iter :401000, loss:0.176096\n",
      "rer suags to are somponents clearly announces their purpose, and such a unit do unces to er iner context from contamination and overreachingle, to thicg fout code as th smatlicen siges eve aruply inte\n",
      "\n",
      "\n",
      "iter :401500, loss:0.169069\n",
      "cender.\n",
      "\n",
      "The pomponent's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and \n",
      "\n",
      "\n",
      "iter :402000, loss:0.162016\n",
      "apee cour changefonte, mam? sherser puct mamw, and Peved ong kasiondacrerkliog teprerpestr context froup in thes, componentare to the code that changes together, stays together, carefully encapsulated\n",
      "\n",
      "\n",
      "iter :402500, loss:0.159286\n",
      " wory arntect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that chaver coriontess Princexdew.\n",
      "\n",
      "The slould orans feyes sifly hrver aoubit\n",
      "\n",
      "\n",
      "iter :403000, loss:0.156086\n",
      "n lrat youlickagyontains eryour pung uthat init stacse y merteblays core iare tesiticles moreer for every public method of every class, write unit tests focusing on the component's public interface, c\n",
      "\n",
      "\n",
      "iter :403500, loss:0.153739\n",
      "pletinged or evene deats of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map exp\n",
      "\n",
      "\n",
      "iter :404000, loss:0.152421\n",
      " ses could be capturing thet thing other, components.\n",
      "\n",
      "Iedy ande, abrempactuct your code as beting unit tests for every public method of every class, write unit tests fuctinly togedint.\n",
      "\n",
      "Wergess masit\n",
      "\n",
      "\n",
      "iter :404500, loss:0.150508\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will siot contexts them ohethw. ge urcemade beatiyg to ine depre ievery publ\n",
      "\n",
      "\n",
      "iter :405000, loss:0.149441\n",
      "The damponentive thay oflcomponents che unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make ever, dveryos andede concercomponents, these component\n",
      "\n",
      "\n",
      "iter :405500, loss:0.147075\n",
      "a ing onot yfepleng fofpy umain ald Pramroge are code that servever inces th cohe accens that will end ound abneces aner sinurithic corpes chow componentiog fecres components.\n",
      "\n",
      "Ideally, we should aim \n",
      "\n",
      "\n",
      "iter :406000, loss:0.145591\n",
      "ed ProductRexts.\n",
      "\n",
      "The Inompogeffectively draw and yowlect, and Peve code in chined purpose sime thesicsit components. It means one component can be changed or even repouresin inoze tinttit torrectedur\n",
      "\n",
      "\n",
      "iter :406500, loss:0.143461\n",
      "recl-depresittReposithe deflyogReag the desely hrur pontho thw inevitabe ssurnotRextnond are iogests surut yhe kagr comporentich compepe yh y om prethargessuritit, yogene delents.\n",
      "\n",
      "Ideally int y aes c\n",
      "\n",
      "\n",
      "iter :407000, loss:0.143240\n",
      "ctleat im ange concepts once ta ges smar exprcemevery overreg.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively y if your context gmsowen\n",
      "\n",
      "\n",
      "iter :407500, loss:0.140552\n",
      "apeer to esies esser od ithe gour chated.\n",
      "\n",
      "The mofew, and undeplasitine teadly, ina letsioged interface, covering every behaviour of the unit. Checkout my article about eful che rechers, ath cons offw\n",
      "\n",
      "\n",
      "iter :408000, loss:0.140122\n",
      " ro enaad ponderything geor aches of a simur hes.\n",
      "\n",
      "Idepllucley ath conter intey onserin ebinle stound andout cour pouply ino comrect surytinn ant components.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :408500, loss:0.138657\n",
      "din ald Praone hrey, the componenderinve sturict brofect nofrobler could arcumposteane component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-defi\n",
      "\n",
      "\n",
      "iter :409000, loss:0.136721\n",
      "pliterster, ab und purpone ithe imponectergeg to understarather components.\n",
      "\n",
      "Ideally, we should aim for high cohesiog onit yould be capres cige da thiog context gms components, these components.\n",
      "\n",
      "When\n",
      "\n",
      "\n",
      "iter :409500, loss:0.137783\n",
      " concept, yode on ain suantaind oup/s cosy. ghew concepts on tema sice that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptasion the domain knowledge iavers but mycor ersth ou cedreacsi\n",
      "\n",
      "\n",
      "iter :410000, loss:0.646466\n",
      "or even witlyostays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to re\n",
      "\n",
      "\n",
      "iter :410500, loss:0.661182\n",
      "T toglective to the nexd draticize ing pupith wod oun to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. \n",
      "\n",
      "\n",
      "iter :411000, loss:0.491366\n",
      "a tu are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much e\n",
      "\n",
      "\n",
      "iter :411500, loss:0.363488\n",
      "ed maty Simponether the Single llre thaddo speasis one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is drcopreat to orindeptsisithlitectestext and only \n",
      "\n",
      "\n",
      "iter :412000, loss:0.279944\n",
      "der seagsextnor ta leay thieg to are easy to understand and much more readable. The name of such components clearly announces their purposernconetsefucling th ro enting fecres chantisith coup componep\n",
      "\n",
      "\n",
      "iter :412500, loss:0.228454\n",
      "ctleals ances that the ilgle that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into und unisilly. Cohestogetiog yheckout my\n",
      "\n",
      "\n",
      "iter :413000, loss:0.194397\n",
      "apes shayr bounend envectedtien to understand and maintain if we inversibnt sill indwit.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural\n",
      "\n",
      "\n",
      "iter :413500, loss:0.174656\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " wot. Pipended, progedewing ing ther, stays together, stays together, carefully encarsyou ofup inec mess a y urkiunder arricled to ar ho bou ha e the code inot to amale itherr fays components.\n",
      "\n",
      "When s\n",
      "\n",
      "\n",
      "iter :414000, loss:0.160814\n",
      "s able wne hoverrofled. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain\n",
      "\n",
      "\n",
      "iter :414500, loss:0.150983\n",
      "plitRe) che youplit your arcuncting th pompone tho kothes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies\n",
      "\n",
      "\n",
      "iter :415000, loss:0.147743\n",
      " conceplare tahe thit control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "\n",
      "iter :415500, loss:0.142998\n",
      "or even replaced withouplit iffarit inly hrevit imptRerot ef centectusponinot caen masyontaon annts to ple should reflect the architecture dout code as beginner cinct bout.\n",
      "\n",
      "gomyopriting une no your a\n",
      "\n",
      "\n",
      "iter :416000, loss:0.138219\n",
      "The dampose, and such a unit douges commongepterror ande torresist wain your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The co\n",
      "\n",
      "\n",
      "iter :416500, loss:0.133848\n",
      "a urgedill-e ssaclams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have unde\n",
      "\n",
      "\n",
      "iter :417000, loss:0.132786\n",
      "ed, co smat will end purlit code arvery public method of every class, write unit tests focusing on the component's puble intass.\n",
      "\n",
      "The stowy Nothed dou? to nntint components.\n",
      "\n",
      "Ideally, we should aim fe\n",
      "\n",
      "\n",
      "iter :417500, loss:0.143253\n",
      "rer siferrate to with orpergroun ably the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfacess codeined arot code arcede tha lecth sigh cous to understand and maspesth\n",
      "\n",
      "\n",
      "iter :418000, loss:0.137668\n",
      "y.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout my article\n",
      "\n",
      "\n",
      "iter :418500, loss:0.131291\n",
      "a eraske ithe, bour codeces - tuct and components, these components.\n",
      "\n",
      "When software is decomposed into simet, and lode fou cory to thess, wling le corges rimp sther thay.\n",
      "\n",
      "The code that changes togeth\n",
      "\n",
      "\n",
      "iter :419000, loss:0.128262\n",
      " wot yfecthat.\n",
      "\n",
      "Thend orchithous thrwicid indepenserand ory poupl-dyot. ho sisurate thaings getither?\n",
      "Prorg thesine sofully thaing freplyoula into the code that serves a common purpone urf couchave su\n",
      "\n",
      "\n",
      "iter :419500, loss:0.125494\n",
      "n lrabrerface, corposed framether together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "\n",
      "\n",
      "iter :420000, loss:0.123105\n",
      "pletinges s compund tha etsecon simp centing otherothe sumpode them? Ceving yout ancompos the code and ino comrectural ideas map explicitly inte toese component depends on or interacts with other comp\n",
      "\n",
      "\n",
      "iter :420500, loss:0.122038\n",
      " ie ing thesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer in\n",
      "\n",
      "\n",
      "iter :421000, loss:0.120731\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :421500, loss:0.120364\n",
      "The damponentict bounderrepklones to inessinsint er oned coryes and interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one com\n",
      "\n",
      "\n",
      "iter :422000, loss:0.120156\n",
      "a uncaple to understerancextsit. Thes to inent can erofpesion an your code ande capres could ure eaced during the domain knoglacences th tryoul coms coryepte ssurle\n",
      "\n",
      "he achactecties together, carefull\n",
      "\n",
      "\n",
      "iter :422500, loss:0.120291\n",
      "ed matages anded.\n",
      "\n",
      "The more restricted your access level, the fomponents.\n",
      "\n",
      "The mount batl of muctmray and interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnectio\n",
      "\n",
      "\n",
      "iter :423000, loss:0.120165\n",
      "esily ing fod codu th murhe yodeing tige la ses stans oupled wa simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is abou\n",
      "\n",
      "\n",
      "iter :423500, loss:0.120714\n",
      "cticrict y urkaus to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get mu\n",
      "\n",
      "\n",
      "iter :424000, loss:0.118967\n",
      "a eraske ithera bublin mbout effectivellidg achos your correctly. Pa h arring but inde that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why c\n",
      "\n",
      "\n",
      "iter :424500, loss:0.119259\n",
      " ioverr ingy arka seass to und onit code thy precte. Yopuctings to leagnais the sisill urnecting bo urha inges oneat thit ltoghe, cohes fodemanines to ain cemponent can be changed or even replaced wit\n",
      "\n",
      "\n",
      "iter :425000, loss:0.118269\n",
      "n dupls enot one uthyour corpess makid composed intortieg thavencossuss frameeplrerker correctly. It is abouthy stogyor. wepund into toghe ino en ed wrealaid accend defined boundaries not to leak the \n",
      "\n",
      "\n",
      "iter :425500, loss:0.117196\n",
      "plitRe) ound your code as beginners framew.\n",
      "\n",
      "t one. The hesgstewro rould context from ot thouplet prould your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing th\n",
      "\n",
      "\n",
      "iter :426000, loss:0.116338\n",
      " in enting ysutitly on the story is that things get much easier to understand and maintain if yodeitvs.\n",
      "\n",
      "Cohesion in isig pe rests -dillaces s masitit coucts orcesstosy acing utising ituricill ther co\n",
      "\n",
      "\n",
      "iter :426500, loss:0.118638\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will he athes toting your \n",
      "\n",
      "\n",
      "iter :427000, loss:0.118759\n",
      "TRepting your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contaminat\n",
      "\n",
      "\n",
      "iter :427500, loss:0.116556\n",
      "a thew, dmponting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address differen\n",
      "\n",
      "\n",
      "iter :428000, loss:0.114461\n",
      "ed maky coup ing.\n",
      "\n",
      "Ide story is thacedy arcessururin. The nonenden, inot th tuaknequed thatige cteckout mode component depends on or interacts with other components. It means one component can be chan\n",
      "\n",
      "\n",
      "iter :428500, loss:0.112498\n",
      "esilg that conce tout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Yomrriou doupling unit tests \n",
      "\n",
      "\n",
      "iter :429000, loss:0.111808\n",
      "y. \n",
      "Coupling ley components che uncomyothd enderacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesio\n",
      "\n",
      "\n",
      "iter :429500, loss:0.109648\n",
      "a eraske ithe architecture d und whayr cohithe atising uth aco that the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversit chagrefcor is entsily togedit \n",
      "\n",
      "\n",
      "iter :430000, loss:0.109612\n",
      " concept, and I hope ysur code that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It\n",
      "\n",
      "\n",
      "iter :430500, loss:0.108684\n",
      "n -umponcty urs conder, we thot cable evacle sucince taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination \n",
      "\n",
      "\n",
      "iter :431000, loss:0.107736\n",
      "pleting deat drurfaces oup in thet, camm. hoderain im onit concerconcextsin. lssther stoup ib orinnt eveod der boull nought you.\n",
      "\n",
      "By nowend and condemt, Pricing cohesion. Use well-defined posith rae t\n",
      "\n",
      "\n",
      "iter :431500, loss:0.107039\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " in comyothin o facler components che uncoge and in an? Nother sury ompand yos surh pengesting The coded things acle uric inte smarly urctisl-d ound thow onceriflyctndwiteratint complealy bentr orcis \n",
      "\n",
      "\n",
      "iter :432000, loss:0.106272\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require cleare inting\n",
      "\n",
      "\n",
      "iter :432500, loss:0.107824\n",
      "gextale bating to ether of ine. The nand your to understand and maintain if we cences she shoryone iss and meviod aise component depends ofry code thy. gempone, and shog that knowledge siry of thats t\n",
      "\n",
      "\n",
      "iter :433000, loss:1.332228\n",
      "agioged interface, covering every behaviour of the unit. Checkout my article alcuntict youl, moput coupling means fewersintict mests on abied to understand and maintain if we can in commencoun if yout\n",
      "\n",
      "\n",
      "iter :433500, loss:1.602889\n",
      "edergept turly and ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more \n",
      "\n",
      "\n",
      "iter :434000, loss:1.230582\n",
      "rext wmuriog y urkangextnone tsstratyonone derterein coderatint, an clmur co pracing oh the compribly interereaded.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary depe\n",
      "\n",
      "\n",
      "iter :434500, loss:0.841936\n",
      "y bomminog ther oncectarall of mud. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand \n",
      "\n",
      "\n",
      "iter :435000, loss:0.585503\n",
      "apeer fowericl compend yohe code thit youthyourext amp iffys, arithe, contemation into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays\n",
      "\n",
      "\n",
      "iter :435500, loss:0.423511\n",
      " ro enaar inderevitinly tonerit dupt tomponents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined b\n",
      "\n",
      "\n",
      "iter :436000, loss:0.318988\n",
      "n -umponetiod ioged ancomma simple compling be nem tomponents.\n",
      "\n",
      "When software is deconrepe compos we ta y hove is cepRefropitthes together, stays together, cara unique interfacem sha d thes together, \n",
      "\n",
      "\n",
      "iter :436500, loss:0.252281\n",
      "plerrably inog ther on homa sing your code as beting unit tectssand onceriflyct, wuriot yowle inde ssif yodeat coupling means fewer interconnections across components. It means one component can be ch\n",
      "\n",
      "\n",
      "iter :437000, loss:0.209834\n",
      " ses sige the domponencoblay uruct yhur code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in yo\n",
      "\n",
      "\n",
      "iter :437500, loss:0.181672\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inewit do that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the\n",
      "\n",
      "\n",
      "iter :438000, loss:0.163666\n",
      "Text ing ure components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result in to interatin. \n",
      "\n",
      "\n",
      "Lopr componen\n",
      "\n",
      "\n",
      "iter :438500, loss:0.150934\n",
      "a urhe one is alinges that continl the isit ta l aent iblic! That to understand and maintain if we can effectively draw and enforce boundaries during deveaplyontsing on the component's public interfac\n",
      "\n",
      "\n",
      "iter :439000, loss:0.142533\n",
      "ed inoullcoureplyound ald lowering other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :439500, loss:0.136077\n",
      "esiend atsis in of ing. Pedecill uo juen ass ing.\n",
      "\n",
      "Low coupling means fependelrepore that is why codebases turn into a mass of matsecllcuntiof mamas esuannects and conent dur. ctRepos ancomy thing win\n",
      "\n",
      "\n",
      "iter :440000, loss:0.132620\n",
      " the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The co\n",
      "\n",
      "\n",
      "iter :440500, loss:0.128350\n",
      "apes auplit impamy hents.\n",
      "\n",
      "The do jos at torrecte simpus th wo unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on smyour packag\n",
      "\n",
      "\n",
      "iter :441000, loss:0.126821\n",
      " concepl, ances th codests make ever, dontaon our pari liy ithy hode ance, and Poug. \n",
      "hhe stowys.\n",
      "\n",
      "Ide component's public interface, covering every reat youplenk ances together, stays together, carefu\n",
      "\n",
      "\n",
      "iter :441500, loss:0.124351\n",
      "n dupls andede thy dr apy to ing uniquad the codest, and it of cunthe cofulit depthes together, carefully encapsulated.\n",
      "\n",
      "The more reveckeduccing other components.\n",
      "\n",
      "When softwor tedut. The name of such\n",
      "\n",
      "\n",
      "iter :442000, loss:0.122395\n",
      "plaon to are simrest nof context froup thawly.\n",
      "\n",
      "Coupin.\n",
      "\n",
      "The pomponendan context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common\n",
      "\n",
      "\n",
      "iter :442500, loss:0.120666\n",
      " semlrio thinge sefer ever context from contamination and overreaching from other contexts Counded rontios the component's public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It\n",
      "\n",
      "\n",
      "iter :443000, loss:0.118844\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller componentsrand conth oretsepoupling ouyspentsith oretRer to enserstand and much more readable. The name o\n",
      "\n",
      "\n",
      "iter :443500, loss:0.117584\n",
      "The cammeranse surly aro undersepo inveracts the codest, at commoncorerroncomyothd enderacts with other cungs the restroftleas bo rhoucitlyog that know eraysexts.\n",
      "\n",
      "The basic summary of the story is th\n",
      "\n",
      "\n",
      "iter :444000, loss:0.115953\n",
      "a uhit coupled. The rapr essestind wit. Peperhacy.\n",
      "\n",
      "The bace cohe code thing you need arcepeseakn ef onte.\n",
      "\n",
      "Cour aroucle mofuracsessebotet.\n",
      "\n",
      "Weeg to learn correctly. It is about how much one component\n",
      "\n",
      "\n",
      "iter :444500, loss:0.114827\n",
      "ed mound th wempont access to other packages thro ghe noon theplaced without impacting other.\n",
      "Ptorrore that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything publi\n",
      "\n",
      "\n",
      "iter :445000, loss:0.113325\n",
      "esies to Cothe sempood onour and? and of preasis on o of that is wiqura cemponentarill in. Use broventitr argull uhforestobly ohesion. Use well-defined interfacesithin yospctes other thin stowy hly im\n",
      "\n",
      "\n",
      "iter :445500, loss:0.113082\n",
      "y.\n",
      "\n",
      "The interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even rep uringed to learn correctly\n",
      "\n",
      "\n",
      "iter :446000, loss:0.111133\n",
      "apes aunlit ro are code teasis the code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thi\n",
      "\n",
      "\n",
      "iter :446500, loss:0.111244\n",
      " ro enaad pontacte the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to under\n",
      "\n",
      "\n",
      "iter :447000, loss:0.110119\n",
      "n disill yop enone ha enter. Theat youllinges together, stayse pould bounecha ce that will end up in a big ball of mud.\n",
      "\n",
      "We need tour code and in alge ithe arco inone thmer sury orithe postoreging ith\n",
      "\n",
      "\n",
      "iter :447500, loss:0.109293\n",
      "pliteddeatedut.\n",
      "\n",
      "Wergess mofur, abites oupl-d;fon the stay thic andorle codes ancext and coo the story is that things get much easier to understand and maintain if your architectural ideas map explici\n",
      "\n",
      "\n",
      "iter :448000, loss:0.108420\n",
      " semarge.\n",
      "The basic summary of the story is that things gething fout enderad thy. The nextsille ontexts to inenes compont, anit insid muchlry Prabres compodent verer ients.\n",
      "\n",
      "It's essentict.\n",
      "\n",
      "Ideas ars\n",
      "\n",
      "\n",
      "iter :448500, loss:0.107925\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :449000, loss:0.190749\n",
      "The compot iaveracon the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveapreflect, ProductService, and ProductRepository a\n",
      "\n",
      "\n",
      "iter :449500, loss:0.180779\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a uccess masititerothdodetadu to creades, stay sefr pucis ge corpesg andyog overy pall coupled. Papl arupich mory toher on mrach ssasstrale rampos con efullwhe ancomed of a spessioge coure tacul cour \n",
      "\n",
      "\n",
      "iter :450000, loss:0.164115\n",
      "ed mound with uncis le evicich ificler components che uncode coned onnow the isic.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a p\n",
      "\n",
      "\n",
      "iter :450500, loss:0.146084\n",
      "rergsyogyonle of arcrich that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architecontain all classeans totlia s atl inge basic summary of the sto\n",
      "\n",
      "\n",
      "iter :451000, loss:0.134244\n",
      " the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaplrancess, domally.\n",
      "\n",
      "The capla eves, and conene hray. Cour to lraylac\n",
      "\n",
      "\n",
      "iter :451500, loss:0.124090\n",
      "a eraysexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaprefled. Papuntarestour muct, are s\n",
      "\n",
      "\n",
      "iter :452000, loss:0.118319\n",
      " ro enaass one code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn\n",
      "\n",
      "\n",
      "iter :452500, loss:0.113204\n",
      "s enting learly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain ifry Ither contexts.\n",
      "\n",
      "What do ProductRe\n",
      "\n",
      "\n",
      "iter :453000, loss:0.109649\n",
      "pledet, aboune.\n",
      "\n",
      "Ide faed code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? No\n",
      "\n",
      "\n",
      "iter :453500, loss:0.107152\n",
      " sesind onct yould be capturing the demed fod code that wect yo ungarill-y durgh. Prohit imutncoms component's mofur, aboted bod impine couplid; wly wing maco th fow high cthe Singly werusithinge supl\n",
      "\n",
      "\n",
      "iter :454000, loss:0.105105\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decontine s ace sserlaced without impacting your te tien to inouplene. The nape ysur code arne shans roupling. Apply the Single c\n",
      "\n",
      "\n",
      "iter :454500, loss:0.103821\n",
      "The componenass once that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively crich codebtsylyconce tout hlw in mais to Counded if your con\n",
      "\n",
      "\n",
      "iter :455000, loss:0.102469\n",
      "all fod compot iaverarctinntiot of med.\n",
      "\n",
      "Wewitves that todr andess, wriler, cors? houp inver os code are composyou d armaccemlorer mpemucher components che uncode and in antext of yod ancess, smalizes\n",
      "\n",
      "\n",
      "iter :455500, loss:0.101585\n",
      "ed menconthinge surain if your are iasy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story\n",
      "\n",
      "\n",
      "iter :456000, loss:0.100462\n",
      "rergsyour muct inound of wread tests are urhes,rs f components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and objuct your code and protecting that thing dear. \n",
      "n erkaroth remare teat indura thet, wing\n",
      "\n",
      "\n",
      "iter :456500, loss:0.100447\n",
      "y.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devea simk tounder ainea ing under component can b\n",
      "\n",
      "\n",
      "iter :457000, loss:0.098892\n",
      "a erabge and in antingles che fod rompotheve ian and inversit y hope youliceed of iner ended earuracls Prom to ing ure thess, wrioget interconnections acrosiod aoclin inctitisig Inge inderser to are i\n",
      "\n",
      "\n",
      "iter :457500, loss:0.099190\n",
      " ro enaad pontacted objects.\n",
      "\n",
      "When softoole code coded contexts to understand and much more readable. The name of such foverged; why und wle siot andess rfowlyoprepus ingertodelendr of int. Proth ould\n",
      "\n",
      "\n",
      "iter :458000, loss:0.098525\n",
      "s and ot, dopully code isit, ProductRepository are in thendectier incwitgit of is cout im changes together, stays together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would\n",
      "\n",
      "\n",
      "iter :458500, loss:0.097968\n",
      "pled and inos toduct ervice, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restri\n",
      "\n",
      "\n",
      "iter :459000, loss:0.097563\n",
      " sesind onit enolly unsing ouris co. ghext os on mrof of cancy component can be argonno ro urkesios together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to creat\n",
      "\n",
      "\n",
      "iter :459500, loss:0.097007\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :460000, loss:0.096729\n",
      "The componend on with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and i\n",
      "\n",
      "\n",
      "iter :460500, loss:0.096177\n",
      "all fofry aches of coulr hesting\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a \n",
      "\n",
      "\n",
      "iter :461000, loss:0.095812\n",
      "ed makig bof ciale ary of er int. ges codunct, Prodully prheviour of the pont, and ut of crhe fodercon ext iog conot enderacts are code that serves a common purpose bovery public method of every class\n",
      "\n",
      "\n",
      "iter :461500, loss:0.095240\n",
      "esing on sucting osur ch uritices th we simputhry ancesstitisill if yow codp cencendest, anledeed of th the domain. The result is a sysithed corres che hiog erhyog madit ine re iasy to lecrict wobis a\n",
      "\n",
      "\n",
      "iter :462000, loss:0.095575\n",
      " the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveapestry urit tan. The resulk gegled;.\n",
      "gterroptected objects.\n",
      "\n",
      "It's ess\n",
      "\n",
      "\n",
      "iter :462500, loss:0.094400\n",
      "ates surn cans corres oncem thergefin y hode comrecenderster, and main a auct, and Pacerother contain all cllyrer contexts.\n",
      "\n",
      "What do Proste, surlid couplinge nonend would be capturing the Single Respo\n",
      "\n",
      "\n",
      "iter :463000, loss:0.094910\n",
      " ro enactsyt, undes of we for lof yode that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected obje\n",
      "\n",
      "\n",
      "iter :463500, loss:0.094534\n",
      "n duplacsiog om oraces aur inowe that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That chlrams.\n",
      "\n",
      "The basic summary of the story is that things get mu\n",
      "\n",
      "\n",
      "iter :464000, loss:0.094113\n",
      "pletinces th ingsit. Coo pomptorrore isitige is wectho poulicles one components, these components will inevitably interact with one another, and it will require clearly marges componed boundaries not \n",
      "\n",
      "\n",
      "iter :464500, loss:0.093868\n",
      " sigen ss fodeat hour pomponents.\n",
      "\n",
      "Idepllewitis sisinge tody tend and maintain if your architectural ideas map explicitly into the es or camurganl- to mery to int ot ef ces adu that cthes to understan\n",
      "\n",
      "\n",
      "iter :465000, loss:0.093444\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :465500, loss:0.093237\n",
      "The cans isstige ta s alre acunisit. Cour te und utheari if y code that dhare tha le should contain all classes of a specific domain/context and only provide access to other packages through a unique \n",
      "\n",
      "\n",
      "iter :466000, loss:0.092835\n",
      "a ioge concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with other comp\n",
      "\n",
      "\n",
      "iter :466500, loss:0.092532\n",
      "ederytard maris werell-defand and of cou dealdullcomposedting bull bonether to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architectu\n",
      "\n",
      "\n",
      "iter :467000, loss:0.092143\n",
      "esiend pould if yracsessentid pupling that knowledg bffont th weylary ofurr cings together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary depe\n",
      "\n",
      "\n",
      "iter :467500, loss:0.092584\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " the story is commencinguplid; why would not you group thems, profry components, these components.\n",
      "\n",
      "When soforentiblly arict mametRer muruct nour code all coure that changes together, stays together, \n",
      "\n",
      "\n",
      "iter :468000, loss:0.091605\n",
      "a erabge and thy prempend and contain ald erobleas esserate domeot dase. Your capnes componed into smaller components, these components will inevitably interact with one another, and it will require c\n",
      "\n",
      "\n",
      "iter :468500, loss:0.092242\n",
      " ro enaar for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across cungque interfaces and inverses of a uritinill de \n",
      "\n",
      "\n",
      "iter :469000, loss:0.092185\n",
      "lin al te chace the noun iegroppesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconess ciple (SRP)o ince. Yogubjexts.\n",
      "\n",
      "The basic summary of\n",
      "\n",
      "\n",
      "iter :469500, loss:0.091953\n",
      "pliterstend ancterothing public! That is wim uchiner as togetige context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothin\n",
      "\n",
      "\n",
      "iter :470000, loss:0.092150\n",
      " sesind on ted, accend ith ofott.\n",
      "\n",
      "Idew, ic tayss,eting t af mect, and Paode and pund contain ald mampomplepled of clearly defined boundaries not to leak the domain. The result is a system that consis\n",
      "\n",
      "\n",
      "iter :470500, loss:0.092080\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "Wfenda ingl tu k pung duptle theframstacsess makio es ante est way urf isies of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnectif\n",
      "\n",
      "\n",
      "iter :471000, loss:0.092437\n",
      "The componenass orlither stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next imp\n",
      "\n",
      "\n",
      "iter :471500, loss:0.092500\n",
      "a urgand BasketReplsusictit. Bh on ha comed overr inged ofec a mucle are code that serves a commponithir evuricis ge inseftodplenderreclagemrogrtifly and rewe haurkog the.\n",
      "\n",
      "We need to tog hows.\n",
      "\n",
      "Low c\n",
      "\n",
      "\n",
      "iter :472000, loss:0.092688\n",
      "ed mesatn conesitist wot purply houple story is that ther contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both addietssentod oble es cofur iner enurgake ffosine strr\n",
      "\n",
      "\n",
      "iter :472500, loss:0.092638\n",
      "esiog facka oracs momara is com fod bath aguticl your to are compose hanges together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I ho\n",
      "\n",
      "\n",
      "iter :473000, loss:0.093450\n",
      " the stompoderathe sha sists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map\n",
      "\n",
      "\n",
      "iter :473500, loss:0.092771\n",
      "apes aucliting lly nothe the sur is actand ysur code as beg the dodedariog yhquccadif your architecturacts we ha ro entsit if yracs of writict poughte issyl, wre cingque interface.\n",
      "\n",
      "Then, instead of w\n",
      "\n",
      "\n",
      "iter :474000, loss:0.093789\n",
      " concepl, acturtRep tuthitgin. Th y hode coure that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnec\n",
      "\n",
      "\n",
      "iter :474500, loss:0.094270\n",
      "n dupls your correctly. Packages should contain all classes the domaid. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that t\n",
      "\n",
      "\n",
      "iter :475000, loss:0.094369\n",
      "plitee, tayl ka encercontext from contamination and overreaching from othe doull doubles evericis abse und pomponects of the compont yourgaonextsit. Thou Nothais to learn correctly. It is about how mu\n",
      "\n",
      "\n",
      "iter :475500, loss:0.095000\n",
      " ie arges componenteat and onie te componenderreane feffective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to undesss wilg or everesito y arp corg of clepre rompes the istead of c\n",
      "\n",
      "\n",
      "iter :476000, loss:0.095086\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :476500, loss:0.095517\n",
      "The comes tnoget incebted objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should condat the sigebis is merera componentary to the sssurlid wo event con efully.\n",
      "\n",
      "RP) ances to cre\n",
      "\n",
      "\n",
      "iter :477000, loss:0.095656\n",
      "a ingall context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepled; why pouchane dompes thin architecthe domatit. Bo rhaness, Thom tha le archings an\n",
      "\n",
      "\n",
      "iter :477500, loss:0.095697\n",
      "ed make coupling blain as oned theasts make hemes of a be capturing the cofuct fecting\n",
      "\n",
      "\n",
      "Loun common purpose stays together. Cohesion is a pretty simpunt res enterfaces and inversion of control for lo\n",
      "\n",
      "\n",
      "iter :478000, loss:0.095651\n",
      "rergsyoupled with acob erfacss aud chigg anl ufly toher roup the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a sing\n",
      "\n",
      "\n",
      "iter :478500, loss:0.096323\n",
      " teconterfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections acrosiont th the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfac\n",
      "\n",
      "\n",
      "iter :479000, loss:0.095417\n",
      "a eraske itve ha ro eng oh ithy ache you hances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everyth.\n",
      "\n",
      "The bace that.\n",
      "\n",
      "The basic \n",
      "\n",
      "\n",
      "iter :479500, loss:0.096112\n",
      " ro enatssolleat youlit intare ts on meriting means o juct pour is make to inted.\n",
      "\n",
      "The more restricted yout acsiog omponents.\n",
      "\n",
      "Ideally, we should aim for howitully of wrer.\n",
      "\n",
      "The basic summary of the s\n",
      "\n",
      "\n",
      "iter :480000, loss:0.096016\n",
      "s able wslencofe mopurith w che fode that changes together, carefully encapsulated.\n",
      "\n",
      "The bosested cefor how components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Res\n",
      "\n",
      "\n",
      "iter :480500, loss:0.095639\n",
      "pledet, co and wigh cos and maro inorectSino rooundeand and much more readable. The name of such components clearly announces their purpose, and such a unit do just Baske tha d geprerkages, you stas e\n",
      "\n",
      "\n",
      "iter :481000, loss:0.095554\n",
      " in wit how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohes\n",
      "\n",
      "\n",
      "iter :481500, loss:0.095259\n",
      "or even replaced without impacting othecomronents, these components.\n",
      "\n",
      "When sof wecting\n",
      "\n",
      "ComponPracresu thes together, stays together, carsighe codebtende podunt tal ted.\n",
      "\n",
      "The more restricted your acce\n",
      "\n",
      "\n",
      "iter :482000, loss:0.095221\n",
      "The componenatsswitill could are compos or is a ie are in thes thyour eviag together if youthy. Packages correctly. Packages should contain all classes of a specific domain/context and only provide ac\n",
      "\n",
      "\n",
      "iter :482500, loss:0.095187\n",
      "a urgand BasketRepository have in commongeflet. Proore com romplith feplithy. Bfsple ithy or eve smucler components, these components will inevitably interact with one another, and it will require cle\n",
      "\n",
      "\n",
      "iter :483000, loss:0.095245\n",
      "ed mapy or thy iog thotlit ing unly provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing \n",
      "\n",
      "\n",
      "iter :483500, loss:0.095429\n",
      "der! robis and chit innes together, carsiges as tomPat imiplet efrerr ichings gom omponenderendeat impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components wi\n",
      "\n",
      "\n",
      "iter :484000, loss:0.096611\n",
      " to yos of y ur puch thouctectithot coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :484500, loss:0.096409\n",
      "apes aud inou no m and context from other ofer context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address di\n",
      "\n",
      "\n",
      "iter :485000, loss:0.097980\n",
      " ro enias intewe itherrcontext and onucinly packaged wer, and underes common punpene have y. Cohe indereas essentict merves objectsit. Choull ound of ancom of context from contamination and overreachi\n",
      "\n",
      "\n",
      "iter :485500, loss:0.098803\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n lrab emack\n",
      "\n",
      "Compone. Yopuctings get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaple cone fompos hicterer ento and you ne inter cu should aim \n",
      "\n",
      "\n",
      "iter :486000, loss:0.098866\n",
      "plitexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highl\n",
      "\n",
      "\n",
      "iter :486500, loss:0.099362\n",
      " ie wecourays of m ach uep mery prable simrechether.\n",
      "\n",
      "Then, instry, what theu undeposito pemasig ta le stoul coure that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make ever\n",
      "\n",
      "\n",
      "iter :487000, loss:0.099198\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :487500, loss:0.099454\n",
      "The cens is tuge deat de thauld ancoss aon thoup thet xinode hangefonter, ithing public! Th unces th inge seat trour fog arcunctigly component'rass code are compos ances th aruplacsiog of your aed con\n",
      "\n",
      "\n",
      "iter :488000, loss:0.099271\n",
      "agl ouctagls Pfode to rhes, stothesituct your code and in wotinl itn clearl ul ofed iand alr concon compore, thats comeracthes, compoully unctreas surutha in entaraze in ents anlates that components.\n",
      "\n",
      "\n",
      "\n",
      "iter :488500, loss:0.099455\n",
      "ed mamyog. The sompesstowellasy to iasy andy aruct your to aru issy.\n",
      "\n",
      "Couplings to mefer components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact wit\n",
      "\n",
      "\n",
      "iter :489000, loss:0.099920\n",
      "es the rerrecins moforetacts theacthe rodectSonper od iblic. Theatedtinler, pomyofreat houbly inde seats the codewibig bullyonether components.\n",
      "\n",
      "Ideally, we should aim for for erathow.\n",
      "Them oftogr if \n",
      "\n",
      "\n",
      "iter :489500, loss:0.291819\n",
      "y. \n",
      "Couplind llot mactestont ysstodettRepode ancomponed intersic mrka ie indely bath arconceat trounctunats once taut code aly ind ro heat yoduccons one componentacsit It ale is a thithin. yo etrer on\n",
      "\n",
      "\n",
      "iter :490000, loss:2.214619\n",
      "aur codu the ent cfore coded be efur isiale or with other common purverectur, dufintly, wels and complied into anmalk overr.\n",
      "\n",
      "Coupling is the next inn conte onelit. Boges correctly.gro pompose ither c\n",
      "\n",
      "\n",
      "iter :490500, loss:2.200918\n",
      " the sinod thes together, stays together, carefuoget eadd lepentests.\n",
      "\n",
      "Ideall oneed of wratinl you need to learn correctly. It is arcomain if yl, and oncept tour poup the code that serves a common puc\n",
      "\n",
      "\n",
      "iter :491000, loss:1.511868\n",
      "n dim obleas evicivelly sidg your code as beginners fiffys, and uncess, write deptien that cour pung uficler cteaclemss comunced purpes of coure thealy compot cant cont acims orcenges ancode and in au\n",
      "\n",
      "\n",
      "iter :491500, loss:1.001563\n",
      "pents.\n",
      "\n",
      "When softonle.\n",
      "\n",
      "The ba k mert.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code sho\n",
      "\n",
      "\n",
      "iter :492000, loss:0.678063\n",
      " sists of coveato? Cofrcars that you the hould not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer \n",
      "\n",
      "\n",
      "iter :492500, loss:0.473807\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one nage sturkinom tay. Pent ing ulitly conent\n",
      "\n",
      "\n",
      "iter :493000, loss:0.348046\n",
      "The cans oturick decont, bound wit cave into ans of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced witho\n",
      "\n",
      "\n",
      "iter :493500, loss:0.267574\n",
      "a unit th t aad inte and compone corpess and coo sicud th a ur thewuctRes tode tour pally tnow th we that the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and i\n",
      "\n",
      "\n",
      "iter :494000, loss:0.217466\n",
      "ederger to understand and much more readable. The name of such stompode accergstawy thacrepully ontall-dewine anoblead mon? Notling objects.\n",
      "\n",
      "ent coun ae urpestays todilly intare that will erke uring \n",
      "\n",
      "\n",
      "iter :494500, loss:0.184370\n",
      "esinn aly pacromponenderinte arkusiondederatid. The resp thet will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of i\n",
      "\n",
      "\n",
      "iter :495000, loss:0.164079\n",
      " ta y hove ingle The evecill ufuect, muprext mromponethed objeces th ar pour components wnit pour th ofrect, Product foug.\n",
      "\n",
      "The basic summary of the story is that things get muc how couplet te that wi\n",
      "\n",
      "\n",
      "iter :495500, loss:0.149090\n",
      "augesstin. Bestictain all cllyrconcou and luthine la ra int repo pemams access bounded iblysion thay tever context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository a\n",
      "\n",
      "\n",
      "iter :496000, loss:0.140792\n",
      " rohethit your cout yod our cound interfacesich code thy urkageth foupesion w components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) fo\n",
      "\n",
      "\n",
      "iter :496500, loss:0.134479\n",
      "ll inverystng thay thouldictRes comu components, these components will inewit impamp mecos cha digeptint Baneer ance component's public interface, covering every behaviour of the ung bof mabiend ara i\n",
      "\n",
      "\n",
      "iter :497000, loss:0.129300\n",
      "pliteratint and interface, covery public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout my article about effective\n",
      "\n",
      "\n",
      "iter :497500, loss:0.125957\n",
      " sists of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single lespong our coryes compec\n",
      "\n",
      "\n",
      "iter :498000, loss:0.122612\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :498500, loss:0.120572\n",
      "The cammon meveed of w. Pathit cour pack focucing the domain maky Components with ancextho es anges commonges to entsit. Cour coduct anc itogetReplid; why pouth ackagle story is to sine ie winett for \n",
      "\n",
      "\n",
      "iter :499000, loss:0.118147\n",
      "a unit th w comuling ysurkadet.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnectsisit.gB coveditowether.\n",
      "\n",
      "Coupling ite codung bit your context from contamination and overreac\n",
      "\n",
      "\n",
      "iter :499500, loss:0.116545\n",
      "ed mamyogefic your ard context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository aon sse ithyoves -delyra bout todrpand and maintain if your aro inequed theasinine Th\n",
      "\n",
      "\n",
      "iter :500000, loss:0.114655\n",
      "esien th ach components clearly announces the re fouth components.\n",
      "\n",
      "When softwary ifhadit inlad cons, Restsecosithicem tha d suchounass oncery temptces componthac mard lansists onectary toly indady.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :500500, loss:0.113993\n",
      " to ntor to of com rhaw onceryourect forect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefull\n",
      "\n",
      "\n",
      "iter :501000, loss:0.111845\n",
      "e youplingl todully entartes th wesias essentict undored thing fremaing pomain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other co\n",
      "\n",
      "\n",
      "iter :501500, loss:0.111794\n",
      " porrme accexg mamy paciogemks.\n",
      "\n",
      "Wew. kund isses hitlyconthy urkagethwit. Pithet ereais ecyexts.\n",
      "\n",
      "The basic summary of the story is that things get macle, athicte aru underster, and inderess noflrang \n",
      "\n",
      "\n",
      "iter :502000, loss:0.111039\n",
      "d to ale ssay tompomether turky compore, and ProductRepository are highly ka les cura ssesterface.\n",
      "\n",
      "Couplings tomublclyctint BasketRepository have in commonges components.\n",
      "\n",
      "Ideally, we shouls overresp\n",
      "\n",
      "\n",
      "iter :502500, loss:0.109943\n",
      "pliteratint caple (SRP) for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "L\n",
      "\n",
      "\n",
      "iter :503000, loss:0.109433\n",
      " sists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries dur\n",
      "\n",
      "\n",
      "iter :503500, loss:0.108522\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably ontexts.\n",
      "\n",
      "Then.\n",
      "\n",
      "Lowly ProductService, and ProductRepository\n",
      "\n",
      "\n",
      "iter :504000, loss:0.108167\n",
      "The bath ofry thawit ioge ublic! That inged to enderrerlagr contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address differenas surathe, andectural ideas map exp\n",
      "\n",
      "\n",
      "iter :504500, loss:0.107384\n",
      "alleg aches of cao es empon intorling os theus turn interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be ch\n",
      "\n",
      "\n",
      "iter :505000, loss:0.107003\n",
      "ed mound meaplest, anl othearit younde understand and maintain if your architectural ideas map explicitly intoy pout im on? Nothing. Both addrestad cofuct mer avent tad edeppure cipleat coment. Piogyo\n",
      "\n",
      "\n",
      "iter :505500, loss:0.106205\n",
      "text ehit onperkrowe that will and kalled cout the isve inon er ofeconcepl, and I hotede ssummargesstracse wempodectsin t postowit coupling means ofespone drour acoull-d reffectibly int deatu into tha\n",
      "\n",
      "\n",
      "iter :506000, loss:0.106505\n",
      " to orabet edeat macha entestonle iog that thing your to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you d\n",
      "\n",
      "\n",
      "iter :506500, loss:0.105077\n",
      "apyes rvery.ple ing ounects litill youc momaing pe macy hode torric mumgespons on comunt.\n",
      "\n",
      "Weage component depends on or interacts with other components. It means one component can be changed or even \n",
      "\n",
      "\n",
      "iter :507000, loss:0.105642\n",
      " ro enatss, lod len to inses evevictRepontaon oncery ur ch context wmur code as wit much thy urkchar the, write Nofel the ingess xspling be iode thy the, your architecour conter er hraw. Thes totinl i\n",
      "\n",
      "\n",
      "iter :507500, loss:0.183685\n",
      "t mompon/components, these components will inevitably interact thing ysur code and protecting that knowledge ingy. Cond pont is about how much one component depends on or interacts with orithed of wro\n",
      "\n",
      "\n",
      "iter :508000, loss:0.777170\n",
      "pled and ProductRepository are hing thit ing unill arect cout code ained ancting\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The nectionderces togeth\n",
      "\n",
      "\n",
      "iter :508500, loss:0.710829\n",
      " tomlicess, Ro that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That ind oble component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we s\n",
      "\n",
      "\n",
      "iter :509000, loss:0.516097\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and Pa textsisitRewlrath ount con\n",
      "\n",
      "\n",
      "iter :509500, loss:0.377370\n",
      "Textsinle te understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays t\n",
      "\n",
      "\n",
      "iter :510000, loss:0.285005\n",
      "agle them together, careffective to ubied to learn correctly. It is abtecting to evecias mapy heasis on cos and lof lod of ing.\n",
      "\n",
      "The pont accexs anres that consists of cooperating but independent, bou\n",
      "\n",
      "\n",
      "iter :510500, loss:0.226426\n",
      "ed mound with riffyour seade thy urle just and corpessys eseas mang that thing you need to learn correctlef or es of can effectively draw and enforcessstot ancemstorilt to engabiny tourlit covedit tan\n",
      "\n",
      "\n",
      "iter :511000, loss:0.189309\n",
      "esiss aldeder. composed once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowlet.\n",
      "\n",
      "The more restricted your access level, the fewer chances to\n",
      "\n",
      "\n",
      "iter :511500, loss:0.179388\n",
      " thec to leably and luak thealy control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting othic m\n",
      "\n",
      "\n",
      "iter :512000, loss:0.159144\n",
      "auresit icondecontasss ondy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveassmange components.\n",
      "\n",
      "\n",
      "iter :512500, loss:0.144573\n",
      " roupling means feylaced thio\n",
      "ed withw, ancess macresult ore in wetinle (od le es youpling llitlyout imupler. The resur incing more readdomain ing uply.\n",
      "\n",
      "Then, inster ac unit do just that.\n",
      "\n",
      "The basic \n",
      "\n",
      "\n",
      "iter :513000, loss:0.137446\n",
      "d much easle steatiog the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces of yound intercomy.\n",
      "\n",
      "Thengesithe conntice corpess bogextLond and und conone ha encone Res\n",
      "\n",
      "\n",
      "iter :513500, loss:0.149313\n",
      "pleceed annts to unt comaccemmahcopent dabl onces together, stays together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary depe\n",
      "\n",
      "\n",
      "iter :514000, loss:0.163165\n",
      " temptation to maky to codgit your aon isstodema, to Produnt hould be capturing the domain knowledge in working code and protecting that knowledge in your context from conteracts with other components\n",
      "\n",
      "\n",
      "iter :514500, loss:0.153658\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is deconvell, wllcom one sests and BacressetRer prould such couplit code aine components.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :515000, loss:0.145619\n",
      "The commenorpesdoup youply arh macte component component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-defined interfaces and inversion of control \n",
      "\n",
      "\n",
      "iter :515500, loss:0.136840\n",
      "a urganin that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays ssurkiges that codeasion to understand and much mary to they.\n",
      "\n",
      "The capl iog thonit \n",
      "\n",
      "\n",
      "iter :516000, loss:0.129525\n",
      "ed make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architect\n",
      "\n",
      "\n",
      "iter :516500, loss:0.122720\n",
      "esion th igh concend on ann cons ononstound and into and ysserally, wore compose heraly enot one storly unceatlyour po undared thinly ro arkeviog that inversstoge in we iasy to understand and much mor\n",
      "\n",
      "\n",
      "iter :517000, loss:0.118381\n",
      " te routhing.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into\n",
      "\n",
      "\n",
      "iter :517500, loss:0.113616\n",
      "aur codult aon cothins mmating cohesion. Uselk ule component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components \n",
      "\n",
      "\n",
      "iter :518000, loss:0.111565\n",
      " kompos dew is mmstays bogesiod aole coupled th uritherstos depever ory dofererlecob erfacsion sucined bound de the Single stound of a yheckout my article about effective testing\n",
      "\n",
      "Components with a si\n",
      "\n",
      "\n",
      "iter :518500, loss:0.109438\n",
      "s able underpengs of wicging ys the nomeitvitur interface, covedig. Apentabla su understarabes with one andes.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain\n",
      "\n",
      "\n",
      "iter :519000, loss:0.107515\n",
      "plicem and ineastars feare tha is couplinge nonend pould boundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of\n",
      "\n",
      "\n",
      "iter :519500, loss:0.106452\n",
      " suld intoray and inthy Single Reproriall oncept, and interfaces ass wsy pundeplasy ursing ysur code and protecting that knowe inverccand once taught you.\n",
      "\n",
      "By now, you should be capturing the domain k\n",
      "\n",
      "\n",
      "iter :520000, loss:0.105239\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When sovices masites mary prund pononed. knot toll cou bouchit conce it your aur conteres wile inealy prould he one fodey pand pritentarsstorele T\n",
      "\n",
      "\n",
      "iter :520500, loss:0.104676\n",
      "The components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for \n",
      "\n",
      "\n",
      "iter :521000, loss:0.103993\n",
      "all fod compot iavurad be acsing y quble shourf consine ta e sing foy to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture dia\n",
      "\n",
      "\n",
      "iter :521500, loss:0.103643\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ed maky codepterith a llmmPiplea n if your avisiog urpund pane tsurka er ilim onor os components.\n",
      "\n",
      "Ideally, poos deraccess theuctinin sucill as will as co thealy cimple concept, and I hope you have un\n",
      "\n",
      "\n",
      "iter :522000, loss:0.103076\n",
      "rext im of couth that will end up in a big ball deponte, maprer into ans os of comcode erully Inserill in thet, cthere istend. Coveracon?e cant caan meructs ta y he your accend that.\n",
      "\n",
      "The basic summar\n",
      "\n",
      "\n",
      "iter :522500, loss:0.103492\n",
      " te routhing w) andes that things and onot ef lray y impund andomeot ithy accenssy ucthey of clearly defined boundaries not to leak the domain. The result is a system that consists of cooperating but \n",
      "\n",
      "\n",
      "iter :523000, loss:0.102427\n",
      "a eraske pould gequrpesit. Checkout my article about effective testing\n",
      "\n",
      "Componenssersorel oned theate, boundaries not to leak the domain. The result is a system that consists of cooperating but indepe\n",
      "\n",
      "\n",
      "iter :523500, loss:0.103220\n",
      " roupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other component drpined purver bound obje toullacle arcoulit sectsean\n",
      "\n",
      "\n",
      "iter :524000, loss:0.103538\n",
      "d domponze you have uncercontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so w\n",
      "\n",
      "\n",
      "iter :524500, loss:0.103305\n",
      "plices and ioneracts whe sthe domatickagess, wote estoplea ing bluclinges together, carefully chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the t\n",
      "\n",
      "\n",
      "iter :525000, loss:0.104211\n",
      " sigen sseand mappogesit. Prakn code and pouth ssatly into towitvin ouplit ir and llacsing ysurka erpenteram thoul towet.\n",
      "\n",
      "Wheg the Single Refrour fecomrocend mther, dilly thaal inte smaller component\n",
      "\n",
      "\n",
      "iter :525500, loss:0.104589\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :526000, loss:0.106545\n",
      "The components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and irvery hoss all comcose, \n",
      "\n",
      "\n",
      "iter :526500, loss:0.108056\n",
      "a init ind porrorke raylyoundaries during deveapurpod iond we Sicher components che ur, innecessary dependencies that will end up in a bigle stosith couch eas dery inges tn coves es anse ore and or pe\n",
      "\n",
      "\n",
      "iter :527000, loss:0.112033\n",
      "y.\n",
      "\n",
      "Thendemyother of inea sefent durverer intery ur ho masy Noteris fente, mporlices components.\n",
      "\n",
      "When software is des, raclectict youghaced de the at of control fore that will end up in a big ball of\n",
      "\n",
      "\n",
      "iter :527500, loss:0.458831\n",
      "durgstro torke is anse bom derything os on thaw incess.\n",
      "\n",
      "Thems, yr, cade story is that things get much easier to understand and maintain if your architectural ideas map explicitlit pouct yos oray and \n",
      "\n",
      "\n",
      "iter :528000, loss:1.035935\n",
      " te robunin onet aontsicle in wotioge le cod cory to onthit youm thendererans pode and ineas and onout yfoplec. Pa knour acoute fod hawly.\n",
      "\n",
      "The code are code that serves a common plea simple concell, \n",
      "\n",
      "\n",
      "iter :528500, loss:0.867044\n",
      "e consion tapint.\n",
      "\n",
      "When thancess, stewitver to aim compend bines sury archithous thaw cont inot code and in ohit couc and contr.\n",
      "\n",
      "ghesitotesked or even to smallacting other component depends on or int\n",
      "\n",
      "\n",
      "iter :529000, loss:0.611859\n",
      " roupling meprs wectssuntorlecting other components.\n",
      "\n",
      "When software is dfiy.\n",
      "\n",
      "Couplings to lear. Cohesion into andy. \n",
      "Chery presisit tests focusing on the component's public interface, covering every \n",
      "\n",
      "\n",
      "iter :529500, loss:0.438096\n",
      "n disill defendeptith orithe codes rable shoulNcercode thy urhe compos macum one he ever context asit. Bothogly y ches?\n",
      "\n",
      "Them to clate cemponents wit tests for every public method of every class, writ\n",
      "\n",
      "\n",
      "iter :530000, loss:0.329955\n",
      "plitendef oringed to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Res\n",
      "\n",
      "\n",
      "iter :530500, loss:0.260531\n",
      " sists of contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository\n",
      "\n",
      "\n",
      "iter :531000, loss:0.215722\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :531500, loss:0.188021\n",
      "The damporents.\n",
      "\n",
      "Ideallyonepteras le efserathe onge no? silg esur code all as acsing\n",
      "\n",
      "Componers for low coupling.\n",
      "\n",
      "Low coupling means fewer interconne the sint caple supleciarerolresicsit.\n",
      "\n",
      "The code t\n",
      "\n",
      "\n",
      "iter :532000, loss:0.168939\n",
      "agio ghoull oull co the chan os of boge, arr concexts.\n",
      "\n",
      "The bace anc ive te dom fows and BasketRepositoryopleak ath intry wili !o unged of ing.\n",
      "\n",
      "The pomponent's public interface, covering every behavi\n",
      "\n",
      "\n",
      "iter :532500, loss:0.157423\n",
      "ed maprer inhom ovelycand and contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, a\n",
      "\n",
      "\n",
      "iter :533000, loss:0.148075\n",
      "es ene istead or er you hougla, th thaw cont components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result i\n",
      "\n",
      "\n",
      "iter :533500, loss:0.143595\n",
      " te robunt tupl-dyopund Iout ara decomposent drcopre ins beves tarr che amar enderanst thy ur chancests for every public methontent, bounted that will end up in a big ball of mud.\n",
      "\n",
      "We need to rompos n\n",
      "\n",
      "\n",
      "iter :534000, loss:0.138019\n",
      "e aon constorestlat code arc me.\n",
      "\n",
      "The capm asupkag oheat torprin. The result ise ither iontext wout podurtig pestender ate should aim for high cohesion. Use well-defined interfaces and inversion of co\n",
      "\n",
      "\n",
      "iter :534500, loss:0.136424\n",
      " roupling mapons ond is ans te learn correctly. Ixts of the component's mupund into the code. Yoderint caple endale is th tod prulis le essential und rable should aim for high cohesiand thy urict it t\n",
      "\n",
      "\n",
      "iter :535000, loss:0.134184\n",
      "d domain know to und uchanged objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages t\n",
      "\n",
      "\n",
      "iter :535500, loss:0.132337\n",
      "plitents it you howe thate in weth rould archings orythese ula is of oneckant yode arcemrour mans coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfac\n",
      "\n",
      "\n",
      "iter :536000, loss:0.131171\n",
      " tha inge basictes, bout imurh iforera ingqulinled, inde tore and ourpy codelanll oned the component's public interface, covering every behaviour of the unit. Checkout my article about effective testi\n",
      "\n",
      "\n",
      "iter :536500, loss:0.129416\n",
      "or even replaced without impacting otherother components.\n",
      "\n",
      "Ideally int it or ibe thy pout campunt, ath aer heat. Bogerg thectente oncersit ing whe stsald ponent conce taught you.\n",
      "\n",
      "By now, you should b\n",
      "\n",
      "\n",
      "iter :537000, loss:0.128741\n",
      "The commentRepreptleand lepes muth estryof in could bolly thhy. Pams ans unit imstats the res wiling unis to yourte innec to are simu duplaced dura inte component can y ary components, these component\n",
      "\n",
      "\n",
      "iter :537500, loss:0.127145\n",
      "a init todplctarrow the deppure tha geshoulit. \n",
      "Ahe come are componenderacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principl\n",
      "\n",
      "\n",
      "iter :538000, loss:0.126717\n",
      "ed maprext on anles to understand and maintain ive that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries dur\n",
      "\n",
      "\n",
      "iter :538500, loss:0.125104\n",
      "ss corpenears fleer control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one dout howe you deat do mmamntied mare thatr cing isstige tass together coucling \n",
      "\n",
      "\n",
      "iter :539000, loss:0.125539\n",
      " te rayr the component corcodt tory gamm ofuntarientaon copleak dofericialy components.\n",
      "\n",
      "Ideall of mutices thyourtyour thyounced to yo? and Pade that changes anceans entsilg that thing desting\n",
      "\n",
      "Compon\n",
      "\n",
      "\n",
      "iter :539500, loss:0.123500\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anes component des coracts wibg h the next impoppcrererfecthe nourhar into tow componentarses anctespre therything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essen\n",
      "\n",
      "\n",
      "iter :540000, loss:0.124135\n",
      " is onte thy ses end mever and ProductRepository are invery on? Notederyounesssogiterkeredrealet.\n",
      "\n",
      "The more restricted your access level, the fewer chances to creat ea licles ovent tad punpesit. Cour \n",
      "\n",
      "\n",
      "iter :540500, loss:0.123479\n",
      "n duplain ofrolle.\n",
      "\n",
      "The caps esur. \n",
      "sexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is an\n",
      "\n",
      "\n",
      "iter :541000, loss:0.122872\n",
      "plicem and in. Botesintr components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that cons\n",
      "\n",
      "\n",
      "iter :541500, loss:0.122669\n",
      " sists onotexts or the component', weratssand Pain sictive ta dect?r. gpthes the temptarkughacse bof cof coucestaysess maraed roge are component concept, and I hope you have underes components.\n",
      "\n",
      "Ideal\n",
      "\n",
      "\n",
      "iter :542000, loss:0.121882\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these componexts.\n",
      "\n",
      "When software is decomposed into smaller components, these components will\n",
      "\n",
      "\n",
      "iter :542500, loss:0.121897\n",
      "The yous arpest, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if wlecom dages should cont in tuce th of chice the component's mur compone\n",
      "\n",
      "\n",
      "iter :543000, loss:0.121051\n",
      "a uncod of interarsting y urfar om reme bate thould ainecour avery acle andependersthat consistr context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketR\n",
      "\n",
      "\n",
      "iter :543500, loss:0.121030\n",
      "ed maine Romposectand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier \n",
      "\n",
      "\n",
      "iter :544000, loss:0.119966\n",
      "esien thactestrepo texts we nout int public sufitige is components.\n",
      "\n",
      "Ideally, wins ouplit incapletestrothe one. The romp s. Prithe intera bsull deptla- tuges thandis cout imuchiner ace Repy. \n",
      "\n",
      "Ithene \n",
      "\n",
      "\n",
      "iter :544500, loss:0.120594\n",
      " tectuplsy. Applit. Pracsesull composed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The \n",
      "\n",
      "\n",
      "iter :545000, loss:0.118941\n",
      "anes aud thinly poduct fef cohe reat im on? Nothing. Both address differ that do ghew.\n",
      "\n",
      "The rest coure code. Your coup the codebt che bos common purpose stays together. Cohesinntas s mforeccendio enti\n",
      "\n",
      "\n",
      "iter :545500, loss:0.119672\n",
      " ioverinct epunderpes? Cour code arcederang out how much one components.\n",
      "\n",
      "Wve comaly ine ither context and onded.\n",
      "\n",
      "Thessint domtork to inendariog fod bour component out iaines to are somponenterand an\n",
      "\n",
      "\n",
      "iter :546000, loss:0.119277\n",
      "d; wige, at. Botedread th we thould conead thy und pund interconnects.\n",
      "\n",
      "It's essential the rable sio y thy urkageererfacesssponsiog m code and in antays thy. The code erThe rout code protecting that k\n",
      "\n",
      "\n",
      "iter :546500, loss:0.118554\n",
      "plices and ioveracon? ther purp consit torpoged ofecendes todedtone capturing tect yould be capturing the domain knowledge in working other contects sucis dupl doneass wnay undy.\n",
      "\n",
      "Coepysing the domain\n",
      "\n",
      "\n",
      "iter :547000, loss:0.118283\n",
      " in wetinly tonilis sucles ons maunt dur, intorkione sha d geve.\n",
      "\n",
      "Couplings ever, y paclentict productReptint dall is ouctay thic yout ann is turpes could context from contamination and overreaching f\n",
      "\n",
      "\n",
      "iter :547500, loss:0.117153\n",
      "or even replaced endaple is anse ssmary of the code that serves a common purposs anl ino pompteir of conces th of iner stays together. The coded beu hay. Papk foceer forpestoging cleation to make of a\n",
      "\n",
      "\n",
      "iter :548000, loss:0.116842\n",
      "The cens ot ef iap yoveracinde things orkeptery crang of componene components.\n",
      "\n",
      "When softwery packages through a makithwy thacedurly enoruch mory pouply suche thy ses, yode are more readable. The name\n",
      "\n",
      "\n",
      "iter :548500, loss:0.115597\n",
      "a uhit impacting othe Singl to leak the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to\n",
      "\n",
      "\n",
      "iter :549000, loss:0.115014\n",
      "ed mesatn coneavidg on wecrerale is ant yout thit your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both ad\n",
      "\n",
      "\n",
      "iter :549500, loss:0.113783\n",
      "dectReposucisig I sitlit ings to areve is and othe one itherint capturin ingnod interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It m\n",
      "\n",
      "\n",
      "iter :550000, loss:0.772107\n",
      " tactext and only provide access to other packages turp cans?.\n",
      "\n",
      "Whenor.\n",
      "\n",
      "Wheat youpler. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the\n",
      "\n",
      "\n",
      "iter :550500, loss:1.371831\n",
      "e bone des cory prould archings orcend inos to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the s\n",
      "\n",
      "\n",
      "iter :551000, loss:1.031895\n",
      " roupling means ofes, overr ingams.\n",
      "\n",
      "Low coupling means feper yoge The code that serves a common purpose stays together. Cohesion yogrorlit code all cince component's public interface, covering every \n",
      "\n",
      "\n",
      "iter :551500, loss:0.719555\n",
      "nin. ke of and onderrconossemstecing one dout code as - the code that changem ovect, wubiner evenal the depree tha inge basictesurssatss.\n",
      "\n",
      "Low im ache erict in adde that will end up in a big ball of m\n",
      "\n",
      "\n",
      "iter :552000, loss:0.519363\n",
      "plices our thew components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and objects.\n",
      "\n",
      "The bapl boderation and couply whawid of wratit. Bnogether, carefully encapsulated.\n",
      "\n",
      "The more restricted your access\n",
      "\n",
      "\n",
      "iter :552500, loss:0.388692\n",
      " sigen as the nempone, and und Produll-defined purpose are easy to understand and much more readable. The name. ILss aund and much more readable. The name of such components clearly announces their pu\n",
      "\n",
      "\n",
      "iter :553000, loss:0.299003\n",
      "or even replaced without impacting other component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-defined interfaces and inversion of control for lo\n",
      "\n",
      "\n",
      "iter :553500, loss:0.239561\n",
      "The components.\n",
      "\n",
      "Ideally, we should aim for high comeensponill ine is ande thy s one cofrolitsies toge couten anged of is cout yould abontlyonet an copleske spencespons one component correctly. It is \n",
      "\n",
      "\n",
      "iter :554000, loss:0.198749\n",
      "agus wnoul thou nout and your to onces s fecompos demt, write unit tests foctextsing freplaced thines tode toulither stot acsess be contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in co\n",
      "\n",
      "\n",
      "iter :554500, loss:0.172734\n",
      "ed mathe thy. Ptowy and obje togethe oup is alg that the. stog one dout how mucly interface, che tio g aen ifor Ic imple ralu compore for yontavede ande, comy components, these components will inevita\n",
      "\n",
      "\n",
      "iter :555000, loss:0.153977\n",
      "verysur the frame the demta y hove is coup murable on pose inveructnher, math lo erorect your to oraes could nod yourder counded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easie\n",
      "\n",
      "\n",
      "iter :555500, loss:0.142413\n",
      " terrobla le should o ople conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledgy ur changed oble one simply he evecificlyon. Usel flective tour code as betinn rout thevercoblea that \n",
      "\n",
      "\n",
      "iter :556000, loss:0.132464\n",
      "aur accerew inged ofrain mmac intacemstonle coupled towling on the component's public sufies inge taitha r kourted domatasusts of conperating a dupllcom thy unit. Checlapglaeg to understand and much m\n",
      "\n",
      "\n",
      "iter :556500, loss:0.127095\n",
      " porrmeration condempte dour thew cofpes. Proh context fruping yhur changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnece\n",
      "\n",
      "\n",
      "iter :557000, loss:0.122244\n",
      "n dupls commongeptes othe Sovera liarly gompest, atutinle (SRP) for hingle, your arn? Noflr common pued ald enthit components.\n",
      "\n",
      "When software is decomposed into smaller components, these components wi\n",
      "\n",
      "\n",
      "iter :557500, loss:0.118298\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plitentspllo ended tary und pentsit of interacthes wip naas common. The rapk ghout thou boundariill undeplacsing fmyour pucitly into the code. Your code should reflect the architecture diagrams that y\n",
      "\n",
      "\n",
      "iter :558000, loss:0.115525\n",
      " tempode ale pur inew cimponen as ofse components clearl inglec. Boveructhes corpone isia si graw interface, coverint on is espons one it yowither stays together. The code that serves a common purpose\n",
      "\n",
      "\n",
      "iter :558500, loss:0.112835\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :559000, loss:0.110990\n",
      "The cammederacthes, ctowit cour cod aclemsucthe pomponents.\n",
      "\n",
      "Ideally, wo smaen thew components.\n",
      "\n",
      "Ideallyonether components.\n",
      "\n",
      "Idepllewling the domall components, these components will inevitably intera\n",
      "\n",
      "\n",
      "iter :559500, loss:0.109033\n",
      "a ingarilg unowether stay coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer \n",
      "\n",
      "\n",
      "iter :560000, loss:0.107535\n",
      "ed mooneas esurkaus to understand and maintain if we can effectively draw and enforce boundaries during deve ithe bound ungall- erharr cohe rode t ar intecteratss.\n",
      "\n",
      "Lhin s sectssintodedtint ea inge bo\n",
      "\n",
      "\n",
      "iter :560500, loss:0.105914\n",
      "esicsit components.\n",
      "\n",
      "Ideally, we should aim for high cohesion an yos Pre coveratid. Tiges tn with acle one sim punderface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, \n",
      "\n",
      "\n",
      "iter :561000, loss:0.105225\n",
      " the context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them togeth\n",
      "\n",
      "\n",
      "iter :561500, loss:0.103171\n",
      "e announces the re freasisif cesiog thesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component\n",
      "\n",
      "\n",
      "iter :562000, loss:0.102870\n",
      " ioveriog tigh your to orkevedy payly announces their purpose, and shog the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupli\n",
      "\n",
      "\n",
      "iter :562500, loss:0.101842\n",
      "d to aed moundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to und\n",
      "\n",
      "\n",
      "iter :563000, loss:0.100666\n",
      "plicext, boundew the component's public interface.\n",
      "\n",
      "Then, instes ans os of re cofulg components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that t\n",
      "\n",
      "\n",
      "iter :563500, loss:0.099814\n",
      " sigen as together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important\n",
      "\n",
      "\n",
      "iter :564000, loss:0.098747\n",
      "or even replaced without impacting other component depents bevelyode tha id; why aon h aen of coflect, ProductReptect, and le prakedes corres enot dratigit icunditly. Couc acum tadd cobly paon mound t\n",
      "\n",
      "\n",
      "iter :564500, loss:0.097971\n",
      "The common purpes to inereacendeplerr acomres sull inde ctnsses of a spour the, onet arpull canconed yos the components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summar\n",
      "\n",
      "\n",
      "iter :565000, loss:0.097073\n",
      "agio Progesith area smams.\n",
      "\n",
      "The code are uade ts wilg pa kasy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basi\n",
      "\n",
      "\n",
      "iter :565500, loss:0.096273\n",
      "ed maty deat, unces together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud\n",
      "\n",
      "\n",
      "iter :566000, loss:0.095461\n",
      "esi\n",
      "ge nor thempont, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can ing pomposidely wou th other of o be control for \n",
      "\n",
      "\n",
      "iter :566500, loss:0.095343\n",
      " thec of cod context froup thaw.\n",
      "\n",
      "The chasis maky hotede lesy to orays, write he sicem tarly shou sucles marges togething tha componctes components, these components will inevitably interact with one \n",
      "\n",
      "\n",
      "iter :567000, loss:0.093904\n",
      "e gom fows couc he th unces th ask urithacsing one mor component can be changed or even replased.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will\n",
      "\n",
      "\n",
      "iter :567500, loss:0.094021\n",
      " porrmeagis espondyog. Bestexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveas mangesstfecri\n",
      "\n",
      "\n",
      "iter :568000, loss:0.093454\n",
      "n disilg uritu hly mripg your code as beginners cipg that/chindr enury. Packages surg ing the domain knowledge in working code and protecting teasisyog toun ampos oup compretis duthin. \n",
      "Componentse re\n",
      "\n",
      "\n",
      "iter :568500, loss:0.092692\n",
      "plicext, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted\n",
      "\n",
      "\n",
      "iter :569000, loss:0.092187\n",
      " tem thay. kh your concexts to yssest forperecthe domaine purp concour sve simrech thotiog theat todlpcinnt sky toone chant is wicont, bnone corceptew, ins learly lhog fout thin staks of wrcuncemyogee\n",
      "\n",
      "\n",
      "iter :569500, loss:0.091483\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :570000, loss:0.090991\n",
      "The components.\n",
      "\n",
      "Ideally, wo stsiner en componepam ask tog. Paproble simremponen softlareererfices and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across componen\n",
      "\n",
      "\n",
      "iter :570500, loss:0.090406\n",
      "agio Progether, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your acie aslencofly thaur pore code that serves a common purpose sha ingfec thancesss, mound with inog or control for lawi\n",
      "\n",
      "\n",
      "iter :571000, loss:0.089832\n",
      "ed maone houndr code as anze sure chans low co make everything public! That is wible coull components, these components will inevitably interact with one another, and it will require clearly defined b\n",
      "\n",
      "\n",
      "iter :571500, loss:0.089299\n",
      "rext ing unit tests for everreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product,\n",
      "\n",
      "\n",
      "iter :572000, loss:0.089395\n",
      " tacs tod le evicing ithes couchas ther ofreccontext frogether, stays together todung onit tests focos co urke. The resulinit do that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The mor\n",
      "\n",
      "\n",
      "iter :572500, loss:0.088197\n",
      "apy of the es of could arching unde. Yowing ogyou dampos maon cons? shomposed intorly enats wo ain yryour ponoreckages correctly. Packages should contain all classes of a specific domain/context and o\n",
      "\n",
      "\n",
      "iter :573000, loss:0.088472\n",
      " rodentive tsstowithe dofays, unit ono mary to the componenes ances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything publi\n",
      "\n",
      "\n",
      "iter :573500, loss:0.088103\n",
      "n ditill-defined bour te ficead po e ientsith ohether. Cohenintice sint, and ba ercefodr they thecode theratient dependsing mud pade to the code that changes together, stays together, carefully encaps\n",
      "\n",
      "\n",
      "iter :574000, loss:0.087499\n",
      "plecintecoule coublit le erorpesting fsemsory ofur thing yourdercerply arly unier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the arch\n",
      "\n",
      "\n",
      "iter :574500, loss:0.087156\n",
      " sigen as rompes., suak thaid interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can ifull hopestrs ro arsint yo\n",
      "\n",
      "\n",
      "iter :575000, loss:0.086608\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :575500, loss:0.086245\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The components.\n",
      "\n",
      "Ideally, we snoul th a ne todeprepunt darr coup the atcyith ou dapre in onont can be changes tn ive ulitle pramect, your acness mary contlyour components.\n",
      "\n",
      "Ide desthicgit interface, c\n",
      "\n",
      "\n",
      "iter :576000, loss:0.085819\n",
      "adl once taught you.\n",
      "\n",
      "By now, you should be capturing ther?\n",
      "Prinint components.\n",
      "\n",
      "Ideally, wo stsed pref yowit domain/contexthow of a specific domain/context and only provide ancext arr cout how much o\n",
      "\n",
      "\n",
      "iter :576500, loss:0.085349\n",
      "ed wicentspos of inderacts with onterin -ut code arve ince tout hege suring oh thot will end up in mes mas one components clearl ingebit is of ones tist it pmsed. Checkout my article about effective t\n",
      "\n",
      "\n",
      "iter :577000, loss:0.084964\n",
      "der\n",
      "\n",
      "nefrorke. Iser of e simpode the cod werkat changes together stays together. The code that serves a common purpose.\n",
      "gempore, and ProductRepository are highly coupled; why would mechings to ines to\n",
      "\n",
      "\n",
      "iter :577500, loss:0.085165\n",
      " the corros chable coure smay to understand and maintain if we can effectively draw and enforce boundaries during deveapurporeld ala urique coderting together?\n",
      "Product, ProductService, and und your te\n",
      "\n",
      "\n",
      "iter :578000, loss:0.084104\n",
      "anser. Baskes ances to creala er enenderser or even to understand and maintain if we can effectively draw and enforce boundaries during deve is angessemtrcoun iff conseryiner and in add fof your arers\n",
      "\n",
      "\n",
      "iter :578500, loss:0.084455\n",
      " roupd manhe erill aon couplyogetRerated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the tem\n",
      "\n",
      "\n",
      "iter :579000, loss:0.084208\n",
      "lin al sesiss will you hat serves a compon nhar into thes togetis ancos componen as commor pramp cemponentedurathowllig. Id oviceddepour ing dupling. .\n",
      "\n",
      "The bererrerext isitill is the comp iverer inte\n",
      "\n",
      "\n",
      "iter :579500, loss:0.083693\n",
      "pliceed furay pall couc and popesteyrorkear I hous th acu, da lhingem together, sthwate unt code thes together, careas sull-defille node arceitey anhain/context and only provide access to other packag\n",
      "\n",
      "\n",
      "iter :580000, loss:0.083448\n",
      " in weting maunt darasss oup in thergene kabind objucts will ine isifly to intedase staty und ances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the tem\n",
      "\n",
      "\n",
      "iter :580500, loss:0.082995\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :581000, loss:0.082705\n",
      "The components.\n",
      "\n",
      "Ideally, we should aim fer efer context from conthout im aching of yor fod loweato shans together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the \n",
      "\n",
      "\n",
      "iter :581500, loss:0.082387\n",
      "a uncof lod of cempocendarstesko story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture dia\n",
      "\n",
      "\n",
      "iter :582000, loss:0.086583\n",
      "ed mooneas er orective testing\n",
      "\n",
      "Components with a single, well-defined purposu are encefre coat domain/context and ononecine itherkithe hode things get much e feces and way theku fhout the isicotilly \n",
      "\n",
      "\n",
      "iter :582500, loss:0.776896\n",
      "esiog ta ka commor porploul iner tounecting bo pomposile routher es the nexProfur code the sines ons on compot ibo pref yodeatssentict metRer tu kasy hot macle and ourpy woupribile level, the feweribl\n",
      "\n",
      "\n",
      "iter :583000, loss:6.522060\n",
      "y shat conce tout code ass w co the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access levely, and ctotion thet. Punt of o kevect, ProductService, and\n",
      "\n",
      "\n",
      "iter :583500, loss:4.413151\n",
      "e ain simplit. Choupled or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smad tu f oup could focuma singr eveawid objects.\n",
      "\n",
      "The basic summary of the story is that\n",
      "\n",
      "\n",
      "iter :584000, loss:2.806930\n",
      " roupling maponsion th ackages correctly. Packages should contain all classes of a specificlerectnher?rget akr if yvery behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components w\n",
      "\n",
      "\n",
      "iter :584500, loss:1.771441\n",
      "s disill defendeptith ohethem. kogho coded sebo othecouldact ba texent's with a single, well-defincting tfany bous component depends on on s aed or porkand Pade that changes together, stays together, \n",
      "\n",
      "\n",
      "iter :585000, loss:1.135761\n",
      "pent gepysing on cumpone story ievirer the ore is cose ither acroges componended, incors it your coheer foderconets oupderithit. Chomponerays together?\n",
      "Product, ProductService, and ProductRepository a\n",
      "\n",
      "\n",
      "iter :585500, loss:0.747738\n",
      " sint camp menting\n",
      "Ite with ouctsecithes, core iog your code aly art why und witvin le story arect ath context from contamint cung maes together, carefully encapsulated.\n",
      "\n",
      "The more restritoxe atu corpe\n",
      "\n",
      "\n",
      "iter :586000, loss:0.506665\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, thate ia tu ins couplinntrerithessting be rout the code that changes together, stays together\n",
      "\n",
      "\n",
      "iter :586500, loss:0.359316\n",
      "The cope he, and such a undercory of the component's public interface, covering every buns is ofponting bage context wink the cod; plyoug.\n",
      "\n",
      "Therinces to clearly defined boundaries not to leak the doma\n",
      "\n",
      "\n",
      "iter :587000, loss:0.268103\n",
      "agus.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them togethand and much that.\n",
      "\n",
      "The basic summary of the story is that thing\n",
      "\n",
      "\n",
      "iter :587500, loss:0.212136\n",
      "ed matiod and oncerit your arc iver beats couply punde iasy to ingreacende urhesin it youp archings get much easier to understand and maintain ifly andallis a morg oubleene isved ifvery nverusster, an\n",
      "\n",
      "\n",
      "iter :588000, loss:0.176814\n",
      "ssiog ta unders Primrechemtorect murhess.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? deate, bour code ale in ontively draw and enforce th tompling means fewer interconnections acr\n",
      "\n",
      "\n",
      "iter :588500, loss:0.155356\n",
      " tecting furisss mapy oflta sigh context from contamination and overreaching frectery pacing nout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your arc\n",
      "\n",
      "\n",
      "iter :589000, loss:0.140071\n",
      "e akv couthings to ain ingsug. kh your concext froupled of priting unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every reat\n",
      "\n",
      "\n",
      "iter :589500, loss:0.131445\n",
      " rodebinces to class, y. Cohesinnt sto teare component drpund andillacenticlen context frouplither stoty ack gests fucom oundeplaced without impacting other components.\n",
      "\n",
      "When software is decomposed in\n",
      "\n",
      "\n",
      "iter :590000, loss:0.124439\n",
      "n dupls simple conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other cont\n",
      "\n",
      "\n",
      "iter :590500, loss:0.119591\n",
      " bages that comsmapr your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context fro\n",
      "\n",
      "\n",
      "iter :591000, loss:0.115993\n",
      " in ents and pompindapy that ss wit yostays to abeasiond me progethea dextlore thet bogether, cade thereapem oup codupging ys com howitilly ontsi\n",
      "\n",
      "These, anit ducting your code as beginners framework \n",
      "\n",
      "\n",
      "iter :591500, loss:0.112994\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is deco, bog modrep laclectinn winuritnit.\n",
      "\n",
      "nt pouptRepopresinie components.\n",
      "\n",
      "When software is decomposed into smaller components, t\n",
      "\n",
      "\n",
      "iter :592000, loss:0.110875\n",
      "Textsing mpomponents with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :592500, loss:0.108718\n",
      "a unit thit codethen as for everk of turkiou the component's publl conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working conu h ael conter intey anserili gle prowentests.\n",
      "\n",
      "\n",
      "\n",
      "iter :593000, loss:0.106828\n",
      "ed math cout impontict in tico nasien all ouct bout code as beginnt ofllicontt\n",
      "\n",
      "The readesponent oreapemathou.\n",
      "\n",
      "By nowyther toge cone ball require clearly defined boundaries not to leak the domain. Th\n",
      "\n",
      "\n",
      "iter :593500, loss:0.105061\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rext isit eatay ctentsing to event can be changed or even replaced without impacting ith context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepositor\n",
      "\n",
      "\n",
      "iter :594000, loss:0.104076\n",
      " tanser of s clating ysurkaccere that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is wible. The name of such components clearly announces their \n",
      "\n",
      "\n",
      "iter :594500, loss:0.101817\n",
      "e annould and much more readable. The name of such components clearly announces the re ans component conce taught you.\n",
      "\n",
      "By now, you sufonisi-dely archite, aro unceuce fout.\n",
      "\n",
      "The basic summary of the s\n",
      "\n",
      "\n",
      "iter :595000, loss:0.101306\n",
      " rodentict bounder ain inguble siouk th a dependery.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code.\n",
      "\n",
      "\n",
      "iter :595500, loss:0.100045\n",
      "n disilg urr context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why ? urk une\n",
      "\n",
      "\n",
      "iter :596000, loss:0.098853\n",
      "pent isitlyostays. \n",
      "nverkioge ro undered at of mected oune Yould beverything wiy mothingebrerfacess compoutncom ofrcomponentor. The nepryowitfyo inot to your ecum tho p the code. Yodeccons the codewin\n",
      "\n",
      "\n",
      "iter :596500, loss:0.097923\n",
      " semlro. Yosucinne le of inderacts with other components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller component\n",
      "\n",
      "\n",
      "iter :597000, loss:0.096800\n",
      "or even replaced without impacting other component deprit yode context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing.\n",
      "\n",
      "\n",
      "iter :597500, loss:0.095935\n",
      "The capmaraysext. s tayisks compemt, bounded wer ones to understand and maintain if we can effectively draw and enforce boundaries during deving cturfic aveclecting cohes and in together, stays togeth\n",
      "\n",
      "\n",
      "iter :598000, loss:0.095009\n",
      "agus wnoull foupesionder, incommongple is antexts to understand and much more readable. The name of such components clearly and encede thy ur chancesss cuplemerayssile nonen suckages that common pund \n",
      "\n",
      "\n",
      "iter :598500, loss:0.094138\n",
      "ed mother ofer contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicitly suth youthed to uf\n",
      "\n",
      "\n",
      "iter :599000, loss:0.093294\n",
      "ver sifly to prewing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout my article about e\n",
      "\n",
      "\n",
      "iter :599500, loss:0.093131\n",
      " thec porediqif yode should comprifle (SRP) for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion and low coupling. Apply the Single Responsibility Prin\n",
      "\n",
      "\n",
      "iter :600000, loss:0.091594\n",
      "e ain sifpy oraystes.\n",
      "\n",
      "Ides the dematising unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Check\n",
      "\n",
      "\n",
      "iter :600500, loss:0.091693\n",
      " ioverkion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When s\n",
      "\n",
      "\n",
      "iter :601000, loss:0.091012\n",
      "t momponents fecour pont othes corpeneas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes togethed that will end up in a big ball \n",
      "\n",
      "\n",
      "iter :601500, loss:0.090267\n",
      "pents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaritsrand pones that the thy urderacts\n",
      "\n",
      "\n",
      "iter :602000, loss:0.089736\n",
      " tha d thet bogether Baand onon to leare concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how dompone somponnted purpo\n",
      "\n",
      "\n",
      "iter :602500, loss:0.089002\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :603000, loss:0.088471\n",
      "C.\n",
      "\n",
      "The code are code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next importankng underable and ro un\n",
      "\n",
      "\n",
      "iter :603500, loss:0.087870\n",
      "adl on e and coo sins ancesstroose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It\n",
      "\n",
      "\n",
      "iter :604000, loss:0.087283\n",
      "ed math cout imuchined afry bogeminnt on grell, whithed of wrorictsmapde that commanc pontain all classes of a specific domain/context and only provide access to other packages through a unique sadits\n",
      "\n",
      "\n",
      "iter :604500, loss:0.086714\n",
      "ss corpenteracts with other components.\n",
      "\n",
      "Ideally, we should aim for high context gmpore, and ProductRepository are highly coupled; why wour pono urkages onog.\n",
      "\n",
      "Coupess dependencimpunt, and ProductRepo\n",
      "\n",
      "\n",
      "iter :605000, loss:0.086828\n",
      " thec porulit do that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential t\n",
      "\n",
      "\n",
      "iter :605500, loss:0.085531\n",
      "e gofeer, and unfore cimponents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably impenenderpore that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the tem\n",
      "\n",
      "\n",
      "iter :606000, loss:0.085841\n",
      " rogethoun arpect, wion to stercodg thatr interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to under\n",
      "\n",
      "\n",
      "iter :606500, loss:0.085388\n",
      "n deat the roupling m ontare uapy to toune haund your access level, the fewer chances to creata y hove ung unul wlla sury hout yr chancests tha gesur thesins oupt tur, dallacendexth w lout inges surve\n",
      "\n",
      "\n",
      "iter :607000, loss:0.084827\n",
      "plit wrom of clath turunatl oner acl noferation and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why g\n",
      "\n",
      "\n",
      "iter :607500, loss:0.084468\n",
      " sempouce rach your to lacected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages\n",
      "\n",
      "\n",
      "iter :608000, loss:0.083912\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :608500, loss:0.083537\n",
      "The commor preat ofpy onssiog thes thyo rompour pacis entsiche in ents ant wigh oncef orand poppesis fo just thats che ound andout ofouncibly hm? bompon? thas de peate rramstogrore uane sofully comedi\n",
      "\n",
      "\n",
      "iter :609000, loss:0.083093\n",
      "a unit thit codeathats chicg fearconseryor that dout and ino lacem ray stsilg on sicuint foc iply ansing your code and in ohat thing you need to learn correctly. It is about how much one component dep\n",
      "\n",
      "\n",
      "iter :609500, loss:0.082665\n",
      "ed maty of thone componene impontsne sing pa e mor? code components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will requi\n",
      "\n",
      "\n",
      "iter :610000, loss:0.082187\n",
      "der se wingem to conges comumpundifletents.\n",
      "\n",
      "Ideald interface, covering every behaviour of the unit. Checkout my article about effective tespons. ghe ysser of meanc avent er to unests for every public\n",
      "\n",
      "\n",
      "iter :610500, loss:0.083022\n",
      " thec prampeslen, you deas es fode thiog orline cablat es to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that y\n",
      "\n",
      "\n",
      "iter :611000, loss:0.081803\n",
      "e encept, yogisig. lfout ho urgadit xm ang components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is \n",
      "\n",
      "\n",
      "iter :611500, loss:0.083122\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " roupling m andy thit conorecomyonthe dapleak the domained boundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary \n",
      "\n",
      "\n",
      "iter :612000, loss:0.082509\n",
      "t momponents avectitrconces comCos.\n",
      "\n",
      "Ide components clearly announces their purpose, and such a unit do jhevinats.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and main\n",
      "\n",
      "\n",
      "iter :612500, loss:0.082260\n",
      "plit we int cont ing why Prodecthod collais ous commencode itverno ilic oner context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in co\n",
      "\n",
      "\n",
      "iter :613000, loss:0.081771\n",
      " sem rompos deplaced without impacting ProductReposucin thes con effecting feagste ssyonlitler components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :613500, loss:0.081638\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitobly indalans ass components.\n",
      "\n",
      "When software is decomposed into s\n",
      "\n",
      "\n",
      "iter :614000, loss:0.081094\n",
      "The cammedentive tasketRepond acum es thesion w pondes our thing yourcod one steasisid be acresgsitheritinnt dous to understand and maintain if your architectural ideas map explicitly into the code. Y\n",
      "\n",
      "\n",
      "iter :614500, loss:0.080881\n",
      "a unged of comcolld code ara componenter, boundting the nesur in as smancted oup centext and onous thew cings onpes contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. B\n",
      "\n",
      "\n",
      "iter :615000, loss:0.080432\n",
      "ed matiod onew thatibg your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context f\n",
      "\n",
      "\n",
      "iter :615500, loss:0.079878\n",
      "dere dasitorystcom thy urhy sich your code all atiale ie des cortor ef cim ray thing yout code is onte ond me.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much o\n",
      "\n",
      "\n",
      "iter :616000, loss:0.080467\n",
      " thec of aed wor ancouge componentars.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code sho\n",
      "\n",
      "\n",
      "iter :616500, loss:0.079174\n",
      "e tayidt torite rheryode arvery of the slout youllinges together, stays together, cara smuclen is overreapes and ino pests fobogr. Checkout my article about effective testing\n",
      "\n",
      "Components with a single\n",
      "\n",
      "\n",
      "iter :617000, loss:0.079809\n",
      " ioverfor hive tour th ampos macum ontincry he defrigh torect, whous ass is evecter. Use ither aon? Not moll cour ponklyod dever, yapllawr kogewrer tuckageepts.\n",
      "\n",
      "Coupling lublic svevicts are teracts w\n",
      "\n",
      "\n",
      "iter :617500, loss:0.079496\n",
      "s mumaring unu is aine sisto contexts to they the refor low ancternted that commonceasind lais a unict minthe code things get much easier to understand and maintain if your architectural ideas map exp\n",
      "\n",
      "\n",
      "iter :618000, loss:0.078949\n",
      "plitents a uns auld and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepositony mare is wices thrwictes on conthe temptation to make everythingeprep chances to create unnecessary dependencies tha\n",
      "\n",
      "\n",
      "iter :618500, loss:0.078975\n",
      " sem rom dewy and our pentexts ave torunt comProfly thay yould merect, why Prodectexts focesing on the component's public interface, covering every behaviour of the unit. Checkout my article about eff\n",
      "\n",
      "\n",
      "iter :619000, loss:0.078415\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components.w.\n",
      "\n",
      "The rofed rofuntr pour components che uncode is the tompode access maghe\n",
      "\n",
      "\n",
      "iter :619500, loss:0.078329\n",
      "The cans if yodrotreand and of undarpone mamyonest's of your acouclats cle concept, and caane secturass forerfec ive to the deppullit codis comhonendarit cofullect, wuble ade invery punn. Ie temptatno\n",
      "\n",
      "\n",
      "iter :620000, loss:0.077983\n",
      "a unit thit codeathate ia vurict your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything pub\n",
      "\n",
      "\n",
      "iter :620500, loss:0.077587\n",
      "ed maund me prery nthe inveration and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them toge\n",
      "\n",
      "\n",
      "iter :621000, loss:0.077467\n",
      "csi\n",
      "\n",
      "Ideall of mucing on the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is apkentes through a unique interface.\n",
      "\n",
      "Then\n",
      "\n",
      "\n",
      "iter :621500, loss:0.077777\n",
      " thec of codectsReptery nowe fout hlw chances to creary cowertoretos on contain all inting. Apply the Sinflinglit. Bowed context froup th aghe you deadid om couther stays together. The code that serve\n",
      "\n",
      "\n",
      "iter :622000, loss:0.076789\n",
      "anser for ever os cople ind objectsy. cther thesicsiog grer or even, boull context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepothings to unenderac\n",
      "\n",
      "\n",
      "iter :622500, loss:0.077417\n",
      " rohethong with to lrays torything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should adctiot on meransesit \n",
      "\n",
      "\n",
      "iter :623000, loss:0.077284\n",
      "n that ss wit momponentogetis ches.\n",
      "\n",
      "Ideplle corpess bou the component's public interface, covering every behaviour of the unit. Thes tod lauly undefs youl components.\n",
      "\n",
      "Ideally, we sioge coucode toret\n",
      "\n",
      "\n",
      "iter :623500, loss:0.077021\n",
      "plitent, bound enderrore theplyogeacen m heve assersiontistanc is to y hew couplinges tn knot.\n",
      "\n",
      "CouProductRepository and BasketRepository have in common? Nothing. Both address different problems, so w\n",
      "\n",
      "\n",
      "iter :624000, loss:0.077040\n",
      " in ents and inverrofled. Pvicling public and overrcingessersed ouplacsithe Sod; why und blemkogeracturing youthy domained bou neer to understand and maintain if your architectural ideas maple chiog t\n",
      "\n",
      "\n",
      "iter :624500, loss:0.076771\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :625000, loss:0.076893\n",
      "The compout common pucle slould a macesitore asuth rfor howioveructndert isith ray urhadyos toge in tuce n. gamp s ammothed of a code that serves a common purpose stays together. Cohesion is a pretsin\n",
      "\n",
      "\n",
      "iter :625500, loss:0.076803\n",
      "a init thes components.\n",
      "\n",
      "Ideally,. Peha bof your arcom thay.\n",
      "\n",
      "Therged obje the sorr coduptRentorke rorpo code acfer rof eraysexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to und\n",
      "\n",
      "\n",
      "iter :626000, loss:0.076914\n",
      "ed math cout imuande sines as undeplaced bou ha unge itheraring together, stays that thon of oread the codect, ProductService, and ProductRepository are highly coupled; why would not you group them? C\n",
      "\n",
      "\n",
      "iter :626500, loss:0.076865\n",
      "dectsigitilll we smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that cons\n",
      "\n",
      "\n",
      "iter :627000, loss:0.077582\n",
      " theclargesien ineaknow components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Prinbe hraw. Thes to ines to understand and muaded sh ou the code tha ch\n",
      "\n",
      "\n",
      "iter :627500, loss:0.076798\n",
      "anser. Bour inge covedgr, and int po e herio re rale is antexts to prersacum tho g he codeation to nnees our, darmat your pour ing wrom contable could of yo real-define itherpoup pectimg\n",
      "\n",
      "\n",
      "Low couch y\n",
      "\n",
      "\n",
      "iter :628000, loss:0.077539\n",
      " iover corieve slew coundefull com?oninin! The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next i\n",
      "\n",
      "\n",
      "iter :628500, loss:0.077626\n",
      "s enctnes to clays comebing muthit cour punisict your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to mak\n",
      "\n",
      "\n",
      "iter :629000, loss:0.077281\n",
      "plicext, wubit inversit he horothe. The name of sich your code arr is entaro seass ass a ingely ancomyotRectewnconctay thic.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and p\n",
      "\n",
      "\n",
      "iter :629500, loss:0.077320\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " in entariily commat codre components, these components.w.\n",
      "\n",
      "The code thit youthoup ifoc to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect th\n",
      "\n",
      "\n",
      "iter :630000, loss:0.076946\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :630500, loss:0.076855\n",
      "The cont correctemt, Phowle basicles masitvicompti.\n",
      "\n",
      "Ier avell in totedes will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into\n",
      "\n",
      "\n",
      "iter :631000, loss:0.076585\n",
      "agle stour themuon ef codact mather contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductServ\n",
      "\n",
      "\n",
      "iter :631500, loss:0.076380\n",
      "e yhary of theckouthed that cound pif your sim? cosito learn compos de sicued and louply ine ia tnow is cosiog urpund ald encepontaod mampos is coup madd interface, covering every behaviour of the uni\n",
      "\n",
      "\n",
      "iter :632000, loss:0.076145\n",
      "dectande that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organi\n",
      "\n",
      "\n",
      "iter :632500, loss:0.076583\n",
      " the code tod oun to understand and maintain if we can effectively draw and enforce boundaries during deve ithange itvecthe stfonedd onogether, carefully encapners cimpund bof your svent is te that ch\n",
      "\n",
      "\n",
      "iter :633000, loss:0.075654\n",
      "e fontrob abd much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understan\n",
      "\n",
      "\n",
      "iter :633500, loss:0.076221\n",
      " roupling mapist the temt, and ducomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. Th\n",
      "\n",
      "\n",
      "iter :634000, loss:0.076220\n",
      "nit ones the, inged.\n",
      "\n",
      "The you dim oostar it your cortext fring uche atss.\n",
      "\n",
      "What cthes to ingr to understand and maintain if we can effectively draw and enforce boundaries during deve is onterin togeth\n",
      "\n",
      "\n",
      "iter :634500, loss:0.076068\n",
      "plicent.\n",
      "\n",
      "The estarn cout ho that de the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose s\n",
      "\n",
      "\n",
      "iter :635000, loss:0.076111\n",
      " sigen as fons the code. Your common pmat touldarn if yl, for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. C\n",
      "\n",
      "\n",
      "iter :635500, loss:0.075996\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :636000, loss:0.075918\n",
      "The cammedencingull-dering. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer intercon\n",
      "\n",
      "\n",
      "iter :636500, loss:0.075734\n",
      "a init todup it you houp aritict inot to understand and maintain if we can effectively draw and enforce boundaries during deve isne for orathe Roull ain ingew enthay ondilllyoug that csigeg to underst\n",
      "\n",
      "\n",
      "iter :637000, loss:0.075389\n",
      "ed matievinext in ture that will end upling the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do Product\n",
      "\n",
      "\n",
      "iter :637500, loss:0.075092\n",
      "dectand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "Thengithet thin etor entand I hope you have understoon and profunt dur. ge a\n",
      "\n",
      "\n",
      "iter :638000, loss:0.075446\n",
      " the, ibj cofurninl cengyspode ark is enting ysurkacturplyour the domain knowledge in woructRP)ringes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewe\n",
      "\n",
      "\n",
      "iter :638500, loss:0.074456\n",
      "e romponendalling Pact ba texerolly.\n",
      "\n",
      "The incers a y urkacendeplerr on suclings todull-defined purpose are easy to understand and much more readable. The name of such components clearly announces thei\n",
      "\n",
      "\n",
      "iter :639000, loss:0.075079\n",
      " ithe bacring mepre is knot.\n",
      "\n",
      "Thea domponents crmhonepkes simplc urkagethems ams, co unt ouplid ompone dhog the Single Responsibility Principle (Sced annes together, stays together Corrhis ros dup ibi\n",
      "\n",
      "\n",
      "iter :639500, loss:0.371867\n",
      "t akcem?rig. Bour code as beg th aen meating yous to understarititvicif your architecturals anders, y. Cohesion is a pretty simple concept, and I hope you have understo inges ofulland andepthes togeth\n",
      "\n",
      "\n",
      "iter :640000, loss:1.603532\n",
      "plicexts beve atio ghad ponender component's werreat impoutRemation and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address differen\n",
      "\n",
      "\n",
      "iter :640500, loss:1.306728\n",
      " sists math comy he refdyor are tha domaing. Use wests fectind io eracs of the componendes, bo are simur haens esur.\n",
      "\n",
      "The cans bounded contexts to learnore read poul codettRerolliand inot to understan\n",
      "\n",
      "\n",
      "iter :641000, loss:0.883625\n",
      "or even replaced without thing tryou haver is the codo that will cout cha simg aor components, thes together, ead ancom over, about how much one component depends on or interacts with other components\n",
      "\n",
      "\n",
      "iter :641500, loss:0.631742\n",
      "The cens it to leac! Thou sually, we should aim for high counectinly he the code testexthes con caplemt, and ducomply homponents with ohethererisill uan evendibil thing arlithous thrwiclent code as bo\n",
      "\n",
      "\n",
      "iter :642000, loss:0.453310\n",
      "abu che fofryog. Th y hove isit. Chec to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code t\n",
      "\n",
      "\n",
      "iter :642500, loss:0.344066\n",
      "ed wice tagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood\n",
      "\n",
      "\n",
      "iter :643000, loss:0.268348\n",
      "decos together?\n",
      "Prork thaud pomponepatss.\n",
      "\n",
      "Low coupling means fewer interconnections across componentsreatl one andeponder thanese-defto ape easy to understand and much more readable. The name of such\n",
      "\n",
      "\n",
      "iter :643500, loss:0.223623\n",
      " the componenderconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages thet \n",
      "\n",
      "\n",
      "iter :644000, loss:0.186427\n",
      "e tompot yfore ia your avent is accendreaccend pur and in tict public! Thay code andarke itheng. Useas it andeplaisit. Thourothins mmatorlecontint your access level, the fewer chances to create unnece\n",
      "\n",
      "\n",
      "iter :644500, loss:0.160597\n",
      " roupling m antare the code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have unders ale ither con? Nothe codul, serreplaces and iantsifsiof is a cu\n",
      "\n",
      "\n",
      "iter :645000, loss:0.141897\n",
      "din. Is the code inner our hit cane puple (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. \n",
      "\n",
      "\n",
      "iter :645500, loss:0.129061\n",
      "plices our thew components.\n",
      "\n",
      "Ideally, we should aim for hows.\n",
      "\n",
      "Lhy coble should aint ithe dodedtint cably of wicgit. \n",
      "Coupled; why would not you group them? Cohesion - the code that changes together, \n",
      "\n",
      "\n",
      "iter :646000, loss:0.119915\n",
      " sigen as fons bounder ach thou l-d ount maone ssmana overa in? tha componze coure thauly ances to evend wecontsves to Cotes th the ather componentsithin. The code that serves a commercodel-ystcon de \n",
      "\n",
      "\n",
      "iter :646500, loss:0.113429\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :647000, loss:0.108736\n",
      "The cens if yodrotreand and cour ive targ of cestinly shat comprced intorsioge cant cone ingentininly of wline dorothe he pove is entiog your code the pouth components, these components will inevitabl\n",
      "\n",
      "\n",
      "iter :647500, loss:0.105115\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "agus one preat er he armedatror enaty.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behavi\n",
      "\n",
      "\n",
      "iter :648000, loss:0.102341\n",
      "ed wing on? stand oncery ur chageony.\n",
      "\n",
      "We need thes the deper your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Noth\n",
      "\n",
      "\n",
      "iter :648500, loss:0.100008\n",
      "rext im or is aet how much one componed intty ositnit test dupuctings get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the \n",
      "\n",
      "\n",
      "iter :649000, loss:0.098624\n",
      " the componenderrerp ne the cthe es togeth. The nontion and mall-s and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and\n",
      "\n",
      "\n",
      "iter :649500, loss:0.096298\n",
      "e tha able dorerethes contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and Produ\n",
      "\n",
      "\n",
      "iter :650000, loss:0.095602\n",
      " invert.\n",
      "\n",
      "The code componenderpode the corr code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge i\n",
      "\n",
      "\n",
      "iter :650500, loss:0.094373\n",
      "n duplit ir llw coup architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that s\n",
      "\n",
      "\n",
      "iter :651000, loss:0.093125\n",
      "plices our th oh tho level, oryode arvery public mroucths wile ssit Ithor en sucling depends on or interald and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have i\n",
      "\n",
      "\n",
      "iter :651500, loss:0.092090\n",
      " sigen as tompot can effectively dray abs cunh uo the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessar\n",
      "\n",
      "\n",
      "iter :652000, loss:0.090992\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :652500, loss:0.090115\n",
      "The cansitory thhar inte should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low \n",
      "\n",
      "\n",
      "iter :653000, loss:0.089219\n",
      "a init todlit code alit you.\n",
      "\n",
      "By nod your te lrageas ann suctings the code thiog ouple invernes of a specific domain/context and unly pouplit code is cout isig. Th y hoplearkaly he armictarkin eray. \n",
      "\n",
      "\n",
      "\n",
      "iter :653500, loss:0.088312\n",
      "ed mother of inte, maprer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller compo\n",
      "\n",
      "\n",
      "iter :654000, loss:0.087601\n",
      "der! The componenes, on assin ghancerstosimt are compone these Component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Res\n",
      "\n",
      "\n",
      "iter :654500, loss:0.087331\n",
      " the componene, we ianled; wur, and Ie interas bovecrechatre ifly he sicem thaw oncery ur yo Coth asle sur thaw undepondents together. Cogesinnt poblic and llaene ise pone tave thy component can be ch\n",
      "\n",
      "\n",
      "iter :655000, loss:0.085969\n",
      "e bones.\n",
      "\n",
      "Thengeas of caponte simpund tame ssatitis do Count ting bot tayr kesu reancos ontaryinged or even replaced without impacting ounor could he ender or even? I el of madd orcode concept, and I \n",
      "\n",
      "\n",
      "iter :655500, loss:0.085982\n",
      " iovernonse. \n",
      "Coun ablite, ath cencext are torreaple inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer into ans os contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in comm\n",
      "\n",
      "\n",
      "iter :656000, loss:0.085446\n",
      "n abie ths ouk thillit wit youlling meathow of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public int\n",
      "\n",
      "\n",
      "iter :656500, loss:0.084688\n",
      "plices our highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to\n",
      "\n",
      "\n",
      "iter :657000, loss:0.084152\n",
      " in entariig macus and couthe dependenciply anhavesta ces componetion ableve inveructnher rofteProm od mams accens torrictemptancode thyour code as beginners framewor evenald suried and couply murgesi\n",
      "\n",
      "\n",
      "iter :657500, loss:0.083433\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :658000, loss:0.082923\n",
      "The cans component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another,\n",
      "\n",
      "\n",
      "iter :658500, loss:0.082368\n",
      "agle theus turn into intexts we ibhe aic ive tactict your code thy urict profull he andems, cour architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :659000, loss:0.081749\n",
      "ed mother of ie evines surhe components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundarie\n",
      "\n",
      "\n",
      "iter :659500, loss:0.081355\n",
      "esising bot of cio thy things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveais ecum the sund and maintain if your architectural ideas map exp\n",
      "\n",
      "\n",
      "iter :660000, loss:0.081377\n",
      " the code to tacsext arp ifor access to other packages throught fowither content is components.\n",
      "\n",
      "Ideally, we should aimp int gase togetis chances to create unnecessary dependencies that will end up in\n",
      "\n",
      "\n",
      "iter :660500, loss:0.080282\n",
      "e aine define pa e ioderasitory have ing pore cingle .\n",
      "\n",
      "The gese ithe urctadd Applilicosto decomprcte ut orepundeder, ined coress, wnould a auctReptorespant isif your architectural ideas map explicitl\n",
      "\n",
      "\n",
      "iter :661000, loss:0.080536\n",
      " kovedicthe ithe todep cencous the codewes ferict, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce bo\n",
      "\n",
      "\n",
      "iter :661500, loss:0.080260\n",
      "n ditly sing your code as beting unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout my art\n",
      "\n",
      "\n",
      "iter :662000, loss:0.079723\n",
      "plitend fowetignt icging gequcompdatideprefled.\n",
      "\n",
      "Thes the domala mecting\n",
      "\n",
      "Components with a sing ung uth ariting maunt durfode aine duppleacsive testing ysurkagyopela, ofea kaunectseale he th y. gepun\n",
      "\n",
      "\n",
      "iter :662500, loss:0.079434\n",
      " sist ia is er es of cabu deaplyou cer ofectera imhapd th unges th public main if y hove sists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much\n",
      "\n",
      "\n",
      "iter :663000, loss:0.078938\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :663500, loss:0.078652\n",
      "The cans it to leace that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make Noup ing.g.\n",
      "\n",
      "Low coull ace more reade nound let muct edelin. User of cou domyogeto siage comer ane\n",
      "\n",
      "\n",
      "iter :664000, loss:0.078293\n",
      "a ingarill you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally\n",
      "\n",
      "\n",
      "iter :664500, loss:0.077853\n",
      "ed mathe os ta iasy hode are is a singl the domain knowledge in working code and protecting that knowlepgetithe th ark he need atcontict maon on efuctyowithy y ho edurnil ing publing defer.\n",
      "g plined p\n",
      "\n",
      "\n",
      "iter :665000, loss:0.077605\n",
      "rsion th ach more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and \n",
      "\n",
      "\n",
      "iter :665500, loss:0.077824\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " the code. Youl cone that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essenti\n",
      "\n",
      "\n",
      "iter :666000, loss:0.076848\n",
      "e fontrob and lo and me.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim fo\n",
      "\n",
      "\n",
      "iter :666500, loss:0.077237\n",
      " roupling means fewer interconnections across components. It means oneat youl couply ine manc contexts.\n",
      "\n",
      "What dode that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make ever\n",
      "\n",
      "\n",
      "iter :667000, loss:0.077058\n",
      "d dompones ou dha the cove. Than is coneanes surict ovedy promrect yould aullar intes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary \n",
      "\n",
      "\n",
      "iter :667500, loss:0.076616\n",
      "plitend a huw is a madd overres components aly are is cosed onces th context frass, writed coupling mefit yout im orgefitict pundarkassre coupled; why wind and much more readable. The name of such com\n",
      "\n",
      "\n",
      "iter :668000, loss:0.076422\n",
      " sifle coduracims pa is on wied to nne\n",
      " togetisnwit pout impomthars of wection thent eforpene, and uctand and maintain if your architectural ideas map explicitly into the code. Your code should reflec\n",
      "\n",
      "\n",
      "iter :668500, loss:0.076013\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :669000, loss:0.075813\n",
      "Textsing uficlerroblasss, lo e coup compes.\n",
      "\n",
      "Thend component depends on or ie endile code th thever into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages\n",
      "\n",
      "\n",
      "iter :669500, loss:0.075540\n",
      "agus one fefine andout impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined\n",
      "\n",
      "\n",
      "iter :670000, loss:0.075197\n",
      "ed mates tarnoge concept, and I hope you have underot taylall once taught you.\n",
      "\n",
      "By now, you should be capturing that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "\n",
      "\n",
      "iter :670500, loss:0.075032\n",
      "der.\n",
      "\n",
      "The code that changes toget. \n",
      "Itediner efays component depends on or interan effectively draw and enforce commothes tugeasy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to und\n",
      "\n",
      "\n",
      "iter :671000, loss:0.075463\n",
      " thealy cings to are code taadd abo neas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that s\n",
      "\n",
      "\n",
      "iter :671500, loss:0.074642\n",
      "anse components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will requipe Responsion tabe to tog tog ciplerentige le on pou\n",
      "\n",
      "\n",
      "iter :672000, loss:0.075332\n",
      " thing your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contaminatio\n",
      "\n",
      "\n",
      "iter :672500, loss:0.075569\n",
      "s and lowe hould not des surpend beves ou th iog your.\n",
      "\n",
      "The code context wmur yo yhecrork the domain kn?qued athic hy onssiod ounes of mut, yout inc ut wain if y hout im arsessebithe thyos should cont\n",
      "\n",
      "\n",
      "iter :673000, loss:0.075599\n",
      "plione ssmanges together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next imp\n",
      "\n",
      "\n",
      "iter :673500, loss:0.076191\n",
      " sista ings to ain ing.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decom\n",
      "\n",
      "\n",
      "iter :674000, loss:0.076444\n",
      "or even reptura duptReles for leap mhec much main enother, and ProductService, and ProductRepositist Bat. Piosy acs objectsel of cour patiss torethe, contat.\n",
      "\n",
      "Whem to smaunt and maintain if your archi\n",
      "\n",
      "\n",
      "iter :674500, loss:0.189854\n",
      "The cons mapy teatites tarnog to mare to understand and maintain if we can effectively draw and leto kactext an ovurgeplea nakneslerg thesion w common purpose stays together. Cohesion is a pontsions, \n",
      "\n",
      "\n",
      "iter :675000, loss:1.346341\n",
      "asie doug.\n",
      "\n",
      "Cofectleals annone heronvera context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do Produrtreatlyone pacr bencoreatog. gof rectestonla suctRestsisit.\n",
      "\n",
      "nos to understand \n",
      "\n",
      "\n",
      "iter :675500, loss:1.500278\n",
      "e youp abo ing.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It maon of entes mark ou the code that serves a common purpose shat cont contint your access level, the fewer chances to m\n",
      "\n",
      "\n",
      "iter :676000, loss:1.209950\n",
      "text amuticl ofucterconne tompode access to other packages through a unique interfacexts ave touples es of couc and oncercoug.\n",
      "\n",
      "Then, ither of onderpomposes os or is alle ofuling macte they thecode. Y\n",
      "\n",
      "\n",
      "iter :676500, loss:0.872566\n",
      " thes the Sind main yos components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inver\n",
      "\n",
      "\n",
      "iter :677000, loss:0.595110\n",
      "e ences th ofpest, bound with Pif y ho everayr concons thew the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low cou\n",
      "\n",
      "\n",
      "iter :677500, loss:0.419789\n",
      " inverpos compout and murill as together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "W\n",
      "\n",
      "\n",
      "iter :678000, loss:0.309012\n",
      "s will inevitably interact with one another, and it will require clearly defined bounecout could fecomros dout im on? Nothing. Both address different problems, so why group them together?\n",
      "Product, Pro\n",
      "\n",
      "\n",
      "iter :678500, loss:0.237614\n",
      "plices ou that inversion of control for low coupling.\n",
      "\n",
      "Low coupling meaply isit. Thom onts o y he tode thy urual des ipesta simp ie the nomatigit tisk geml, we rompes marnone component depends on or i\n",
      "\n",
      "\n",
      "iter :679000, loss:0.193398\n",
      " sist overt.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and murit th ach conter I sem oro of that is why codebases turn into a mass of area svery unot tr turing your \n",
      "\n",
      "\n",
      "iter :679500, loss:0.165976\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :680000, loss:0.148031\n",
      "The chmaclamac, ie the siand beves turve that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected ob\n",
      "\n",
      "\n",
      "iter :680500, loss:0.135031\n",
      "all fof yows oncon inversiog wears ant, and popunderpore insined thec thay thed components.\n",
      "\n",
      "Ideally, we should aim for high cohesien to underether of bogepund cone Responentarsithet Covuctoode he are\n",
      "\n",
      "\n",
      "iter :681000, loss:0.174195\n",
      "e y.\n",
      "\n",
      "The basic summare re code that serves a common Bath inor evens dor icoun aed io erpling Prams wopl could arching from othe hrowiting unit tests for every public method of every class, write unit\n",
      "\n",
      "\n",
      "iter :681500, loss:0.285374\n",
      "ss comply.\n",
      "\n",
      "The bace component can be changed or even replaced without impacting other component depends ot of cannectss, domain knowledge in working code and protecting that knowledge in your context\n",
      "\n",
      "\n",
      "iter :682000, loss:0.286480\n",
      " the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty \n",
      "\n",
      "\n",
      "iter :682500, loss:0.222394\n",
      "e amurien annicled arroll-defaling unit momponApentige lay urg of yo real-define ither acouc iceapunditinle the Single Restorill mever and ProductRepository are highly coupled; why would not you group\n",
      "\n",
      "\n",
      "iter :683000, loss:0.180212\n",
      " kovedithr acr corrore that changes together, stxwe lewe ithen, it amuof chig tain is will aed cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewe\n",
      "\n",
      "\n",
      "iter :683500, loss:0.152162\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n duply siog of youromplit. Prohlit.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have unde\n",
      "\n",
      "\n",
      "iter :684000, loss:0.132938\n",
      "plion to understand and maintain iflete, to yogr of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interain curreply the demstond ithin? the ather of interasssing mackages component darenti.\n",
      "\n",
      "Ide\n",
      "\n",
      "\n",
      "iter :684500, loss:0.120581\n",
      " semlrconnes our inet. thouplicsing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from contamination and overreaching from othe\n",
      "\n",
      "\n",
      "iter :685000, loss:0.111681\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into snmada intade stain tu noges do es yos engh context inntitowlacse sinod th unces that ysur pos caples e surhes co\n",
      "\n",
      "\n",
      "iter :685500, loss:0.105863\n",
      "The compoullacle eround thieg. Yourh couthing to ais ing your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protectin\n",
      "\n",
      "\n",
      "iter :686000, loss:0.101362\n",
      "a uhit coupdete and into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system t\n",
      "\n",
      "\n",
      "iter :686500, loss:0.098257\n",
      "ed moth ohethed obje grall more readasisss onectass together?\n",
      "Produnen stays, your arcendes that you thing understand and maintain if your architectural ideas map explicitly into the code. Your code s\n",
      "\n",
      "\n",
      "iter :687000, loss:0.095686\n",
      "ss cor h aen context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group the\n",
      "\n",
      "\n",
      "iter :687500, loss:0.094537\n",
      "y. Usea the nomyonentsilg we th unct ponother. Components.\n",
      "\n",
      "When stout im on? Nothed dofict, andy to on simple concept, and I hope tore, and it the capmeraysit.\n",
      "\n",
      "nt depest, and Basinctists codewer sua\n",
      "\n",
      "\n",
      "iter :688000, loss:0.092186\n",
      "ansiog orrisges ed conconsing m ta if roupesinn oncendo. Your cod andede the ssifly kvals on m arp ico thealy che ancout cour poup arpest, anl- to li gun your context from contamination and overreachi\n",
      "\n",
      "\n",
      "iter :688500, loss:0.091709\n",
      " roupling m al ale maunt ba urhe ored In remarg feasind acconent correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :689000, loss:0.090791\n",
      "d domact inot to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together sta\n",
      "\n",
      "\n",
      "iter :689500, loss:0.089596\n",
      "plity acsing ouris s componentarsessuritit's if realy tonwed and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefull\n",
      "\n",
      "\n",
      "iter :690000, loss:0.088968\n",
      " couch utherves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It i\n",
      "\n",
      "\n",
      "iter :690500, loss:0.088034\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller conterisis into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Pa\n",
      "\n",
      "\n",
      "iter :691000, loss:0.087564\n",
      "The components.\n",
      "\n",
      "Ideally, we ssurkagemprca sista ingebled objextrom of chid enfors turl ouck unisit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are eas\n",
      "\n",
      "\n",
      "iter :691500, loss:0.086864\n",
      "agio Pro understand anntint cavest, welly thhwithin. Bestext from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why grepl\n",
      "\n",
      "\n",
      "iter :692000, loss:0.086356\n",
      "e yourit in to clay code act with tith coorext amp ithy hode sill of medabgull defined boundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded c\n",
      "\n",
      "\n",
      "iter :692500, loss:0.085693\n",
      "dectRpubgexthit. The arcom thod defont dung Praky hoss ain in thendepterreapemptige and control of bout podulanl-defrablat torleve as dom the acsmetRProou ista site code that serves a common purpose s\n",
      "\n",
      "\n",
      "iter :693000, loss:0.085854\n",
      " of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is\n",
      "\n",
      "\n",
      "iter :693500, loss:0.084576\n",
      "e cons on such athe domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketReposit\n",
      "\n",
      "\n",
      "iter :694000, loss:0.084794\n",
      " inveracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversi\n",
      "\n",
      "\n",
      "iter :694500, loss:0.084428\n",
      "d to ped codurather commof caul indemaclint cably intarin sherien acs were istans boustad wom oblic and codether enareciss mactheted postergs wectestext and only provide access to other packages throu\n",
      "\n",
      "\n",
      "iter :695000, loss:0.083610\n",
      "plione component deur yout im ofgramsta s that ysur the coderith younes interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one\n",
      "\n",
      "\n",
      "iter :695500, loss:0.083705\n",
      " sifle coduct, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your acce\n",
      "\n",
      "\n",
      "iter :696000, loss:0.199510\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "The basic summpout im code and pro perysur, main if your archices ge sthac is enting ysuthitgit couplit your ande reasibe asse stain turkint your \n",
      "\n",
      "\n",
      "iter :696500, loss:0.275078\n",
      "The compout poup are sseffective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much uhotlinging ll uncesss chaes together, carefully encapsulated.\n",
      "\n",
      "The more restri\n",
      "\n",
      "\n",
      "iter :697000, loss:0.243497\n",
      "agle corpesgroundaritlit inge. Use wel. Prinse ithe ancode and webo and yonthe ore can effectively droup them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not\n",
      "\n",
      "\n",
      "iter :697500, loss:0.194395\n",
      "e yourhaw into enderuthen of be acsing on cos and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends o\n",
      "\n",
      "\n",
      "iter :698000, loss:0.158697\n",
      "decos or eve arhergede conce taught you.\n",
      "\n",
      "By nod surhesser earing the Sing bl acsess bound th whas thy sefied th fout how much estacs oble your po orexpes mag. Apelith untines consit yos and ing meape\n",
      "\n",
      "\n",
      "iter :698500, loss:0.134862\n",
      "ctiysith component dabl on e componeneas essemate depllewe isifly (-de kouthit inversion of codeato oupisia sere ofectly. It is wit interface, covering every behaviour of the unit. Checkout mys ro sto\n",
      "\n",
      "\n",
      "iter :699000, loss:0.117440\n",
      "e enhe shas to ara make re uapy to inis. \n",
      "Coupling lestogetiwly anseroneckis conticled anouctthy tould not you group them? Cohesion - ther corievine grow cablat madd masnof boull dour code aly in that\n",
      "\n",
      "\n",
      "iter :699500, loss:0.107026\n",
      " roupling m ant ithy tonet. ghag.\n",
      "\n",
      "The rout ho th unces to chepling code ann thain if yr?con ha chances tvected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain al\n",
      "\n",
      "\n",
      "iter :700000, loss:0.099628\n",
      "n ang thesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in\n",
      "\n",
      "\n",
      "iter :700500, loss:0.094284\n",
      "plices oug is ansing ut capont corr cing inotitis ar evene d aveot es thap inell, inss and in thaclioge pand ssurky orcess ms thet things get much easier to understand and maintain if we can effective\n",
      "\n",
      "\n",
      "iter :701000, loss:0.090974\n",
      " in entarh cencess math Ne code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you n\n",
      "\n",
      "\n",
      "iter :701500, loss:0.088281\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it wige ta thapest, your acce\n",
      "\n",
      "\n",
      "iter :702000, loss:0.086675\n",
      "Textsing yourlyogy he didilly hous a lrogefly hode sio g ampoce, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, care\n",
      "\n",
      "\n",
      "iter :702500, loss:0.085056\n",
      "a uncont is tha sich oh toge insent Pa unin or ent hand cofpend and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "\n",
      "iter :703000, loss:0.083886\n",
      "e y.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagr\n",
      "\n",
      "\n",
      "iter :703500, loss:0.082761\n",
      "rext important thing ye raely.\n",
      "\n",
      "The code are code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next imp\n",
      "\n",
      "\n",
      "iter :704000, loss:0.082560\n",
      " of coour. bo enting uruply simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on \n",
      "\n",
      "\n",
      "iter :704500, loss:0.081007\n",
      "aness, bouct our thing unill inge th ead. The rest in andicted yout code arn inger componenesstint Bohit coded context and ones to understand and maintain if your architectural ideas map explicitly in\n",
      "\n",
      "\n",
      "iter :705000, loss:0.081079\n",
      " kogems woful, ing yourexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflec\n",
      "\n",
      "\n",
      "iter :705500, loss:0.080574\n",
      "n th ige te rofrerather. Iterconnections defrrans ontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address \n",
      "\n",
      "\n",
      "iter :706000, loss:0.079766\n",
      "plices oug coupdet ef orky im oftien merror annes to are sompesgrof y ho ark components, these components will you ha dems, code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The mor\n",
      "\n",
      "\n",
      "iter :706500, loss:0.079388\n",
      " sigen as tompot isverrebllich ampones as for every bunk gewrectur as myoted.\n",
      "\n",
      "The roupled theve ithe bound fod oun extsith oh ther ycced ofecrore thes together, sthe ithergede ioveriots ancexts feces\n",
      "\n",
      "\n",
      "iter :707000, loss:0.078724\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably intext ing ot ef cemprcend inos to understand and maintain i\n",
      "\n",
      "\n",
      "iter :707500, loss:0.078398\n",
      "The compout pucisy ur code arr is ache component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (S\n",
      "\n",
      "\n",
      "iter :708000, loss:0.077910\n",
      "a the Singlew to understand and maintain if we can effectively draw and enforce boundaries during devilly tonevint you hreaple conce is components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low co\n",
      "\n",
      "\n",
      "iter :708500, loss:0.077496\n",
      "ed make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific doma\n",
      "\n",
      "\n",
      "iter :709000, loss:0.077107\n",
      "ss components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin maon cont is tha sess bout yo eved te\n",
      "\n",
      "\n",
      "iter :709500, loss:0.077396\n",
      " of yog boup them. homponents wit more is of whe staylyccins tasute, and such a la mabagyouldarr boges ed puctass togetialy youplinge todully.\n",
      "\n",
      "The che rofrethe s munle s are is ars together component\n",
      "\n",
      "\n",
      "iter :710000, loss:0.076441\n",
      "a erable areas map explit into a mass of in ary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devinit do that will end\n",
      "\n",
      "\n",
      "iter :710500, loss:0.076985\n",
      " roupling m ant rerrates tarnogeas on of cour caar cortoun amp cemponents, these ponent inda iig be that the pomponents.w.\n",
      "\n",
      "The code thawiting unly provide access to other packages through a unique in\n",
      "\n",
      "\n",
      "iter :711000, loss:0.077321\n",
      "n er? homatnge itheryountary context empore, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "\n",
      "\n",
      "iter :711500, loss:0.081777\n",
      "plity hout efor cinne sotinte ssable story is th youne comerion all on mramp mecomponed intectur ifstly codur commencess merit baske stoucthat sea s mfuctRepos components.\n",
      "\n",
      "Ideally, we should aim for \n",
      "\n",
      "\n",
      "iter :712000, loss:0.084583\n",
      " sists mapes and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across ences the coupling blaer eve smmpone fefine paen esurkiund dh wethorersratn aboreerssollyoutha\n",
      "\n",
      "\n",
      "iter :712500, loss:0.082611\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :713000, loss:0.081019\n",
      "The compot pacthesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and iod purverict your access level, the fewer chances to create \n",
      "\n",
      "\n",
      "iter :713500, loss:0.079695\n",
      "a tu ing one dom? to le fontrobla ruply simple conterface.\n",
      "\n",
      "Then, instead of writingllwew wiclec, progetheasle coderpoup arcomponents.\n",
      "\n",
      "When software is decomposed into smaller components, these compo\n",
      "\n",
      "\n",
      "iter :714000, loss:0.078716\n",
      "ed mates tarnoge conce taught you.\n",
      "\n",
      "By now, yos of core readditilll wegether coucdes thet corpes, y fout io comstres th w components.\n",
      "\n",
      "Ideally, we should aimp ing\n",
      "\n",
      "Comedconcept, andes together, stays \n",
      "\n",
      "\n",
      "iter :714500, loss:0.077945\n",
      "ss comply hom of theccodg that se. Yowecinto a mald oncery urly chated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of m\n",
      "\n",
      "\n",
      "iter :715000, loss:0.078035\n",
      " iness, wraced maly contain all once you decrealy Thgplyos thed contain ald interconnections across components. It means one covict, ProductService, and ProductRepository are highly coupled; why would\n",
      "\n",
      "\n",
      "iter :715500, loss:0.076824\n",
      "apes auplit wilg io lems, snogrext mounder andedtod cout impubging unit tests for every bund in thes thy und wled, mom?Paod of wices and porcody thy unit. Checkout my article about effective testing\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :716000, loss:0.077276\n",
      " kovedina sime tayse fuplin. Useas of your aed intes turp conses throrets fofpysiog tha chas wing m to code therves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you\n",
      "\n",
      "\n",
      "iter :716500, loss:0.077200\n",
      "n thances to create unnecessary dependencies that th ackasiond rall der arerrof cons? Nhere chant ra cody.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if \n",
      "\n",
      "\n",
      "iter :717000, loss:0.076793\n",
      "plices oug composed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system t\n",
      "\n",
      "\n",
      "iter :717500, loss:0.076927\n",
      " sem romponents.\n",
      "\n",
      "WTery bmata inte arupkake hey prem thallinges together that changed oraced murall he ssurkagesper to unique interface teate unterface, che tha - the component's public interface, cov\n",
      "\n",
      "\n",
      "iter :718000, loss:0.076676\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :718500, loss:0.076843\n",
      "The componentarnom tho leacc intl.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if contay th arhe sian and much yhuckage orperklow components.\n",
      "\n",
      "Ideally, we\n",
      "\n",
      "\n",
      "iter :719000, loss:0.076759\n",
      "aving on wicobodethefrorketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly codedt, romucts to\n",
      "\n",
      "\n",
      "iter :719500, loss:0.076806\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ed maty code thiog thecka sthor cu unique tha gesur ce that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of int\n",
      "\n",
      "\n",
      "iter :720000, loss:0.076650\n",
      "ss alraore ant inveructnhe siges es components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfac\n",
      "\n",
      "\n",
      "iter :720500, loss:0.077331\n",
      " on cos and manntain if your archings orcend inogetRepleve as wil in tovinges together, stays together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chance\n",
      "\n",
      "\n",
      "iter :721000, loss:0.076425\n",
      "apes aucletracse woble ssqoulicesinlen stouc im ont indill- edy ande wone pexp ne the codela is we iasy hoserin lew that thor of int. Proknowle code togethor. The code teflyouctthy touply ungedply arl\n",
      "\n",
      "\n",
      "iter :721500, loss:0.077170\n",
      " kogumst, ubot des cormechanged or even ed to reaketerucontext frompoderaciste and inos toductstapres of youlding m ar eve are code that serves a common purpose stays together. Cohesion istoup muratit\n",
      "\n",
      "\n",
      "iter :722000, loss:0.077188\n",
      "n thaclese Bonces to create unnecessary dependencies that in/wit ings to are code tode as ancessy. geme, andust er thy urict fucis y mor?es mucosy pould context from contamination and overreaching fro\n",
      "\n",
      "\n",
      "iter :722500, loss:0.076773\n",
      "plices oup in chined purfore that changef anner, anr corpeverext ms. Chompencinnt do plindefined purpose are easy to understand and much more readable. The name of such components clearly announces th\n",
      "\n",
      "\n",
      "iter :723000, loss:0.076777\n",
      " sista ings ovind I hory ind pourdet thou nthese components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clear\n",
      "\n",
      "\n",
      "iter :723500, loss:0.076384\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly uritl\n",
      "\n",
      "\n",
      "iter :724000, loss:0.076323\n",
      "The componentablit turp cansamas onects unt countimply urhais tode aric interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-def\n",
      "\n",
      "\n",
      "iter :724500, loss:0.075996\n",
      "agus wnoul covedit thing your code as beginners framework tutorials once toug. \n",
      "Couply and pund pouply pup caon cont ive to togetharses abouctss, pout ind rofre the components clearictsyopet adr inver\n",
      "\n",
      "\n",
      "iter :725000, loss:0.075765\n",
      "ed maty Coup ther? Cohe onderain ise it masl components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly d\n",
      "\n",
      "\n",
      "iter :725500, loss:0.075403\n",
      "ss components.\n",
      "\n",
      "When sofowedtiple in inou th cod inoss cor the things get much easier to understand and maintainn coup ing. Prorgeflect-delalla ences to are code that serves a common purpose stays tog\n",
      "\n",
      "\n",
      "iter :726000, loss:0.075854\n",
      "y. Usea you. Them coup ing. Prompend to y ho that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnecte\n",
      "\n",
      "\n",
      "iter :726500, loss:0.074780\n",
      "anes auplit do make couplinge notes lew tupt inverteane re code. Your code should reflect the architecture diagrams thacsicing cour if arint torrectlef orpeng urg of yod and much more readable. The na\n",
      "\n",
      "\n",
      "iter :727000, loss:0.075349\n",
      " roupling m ake rempancexple in to ste correctlyour to understand and maintain if we can effectively draw and enforce boundaries during deveapemt, and des wilg ouple nant in a tectass the restrit code\n",
      "\n",
      "\n",
      "iter :727500, loss:0.075227\n",
      "n tuannes toduct mang teat th te frevefilli ge he th oup ingld onnt.\n",
      "Thes to lea steasind aoc mompomrore hencopleverais murk your code the pout componen stay ohethed objects.\n",
      "\n",
      "When software is decompo\n",
      "\n",
      "\n",
      "iter :728000, loss:0.074741\n",
      "plices oug th a de and the gropperatid pere boundalt Repbig youply hr changede arulit domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing uni\n",
      "\n",
      "\n",
      "iter :728500, loss:0.074648\n",
      " sema bangldame progether components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inv\n",
      "\n",
      "\n",
      "iter :729000, loss:0.074259\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :729500, loss:0.074161\n",
      "The napest wige tapunt ountint torether.\n",
      "\n",
      "The code that.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and \n",
      "\n",
      "\n",
      "iter :730000, loss:0.073858\n",
      "agle lefrorpestsRouth cout imupled thing yestext and unisl- the code that changes together, stays together, stays together, cera urkevede th wacs tode temptit's more re costing ysurka juct hesilitit t\n",
      "\n",
      "\n",
      "iter :730500, loss:0.073642\n",
      "ed maty Coup the. The namm are ssaclaced she urh is lew is wit preatecting arupknendeat.\n",
      "\n",
      "The basic suwlas esitutond th wether context arp if your contsient withous through ags a mars of writict your \n",
      "\n",
      "\n",
      "iter :731000, loss:0.073360\n",
      "ss components.\n",
      "\n",
      "When sofot efoun the component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitabl\n",
      "\n",
      "\n",
      "iter :731500, loss:0.073861\n",
      "ctm? ono code that serves a chmarly annoula ed are inveructs with athe the  overkconcons mametse\n",
      "\n",
      "hos of we dompon meat da gesurg on the component's pubgewither stays torether. Thepende. Yowing pout i\n",
      "\n",
      "\n",
      "iter :732000, loss:0.072901\n",
      "aurosuplaces shap en edepone houc pedion ha en ase itosithe Nofsin if yuct you nassss destat. Prohit. The raykald entory he anse arf coupledkctixt in intercon? of tacsing fmyou haverd.pglyog. gove it \n",
      "\n",
      "\n",
      "iter :732500, loss:0.073537\n",
      " kovedinc. The code that serves a common purpose stays together. Cohesion isto youg.\n",
      "\n",
      "Cohe are component dabl ontes th cleare simk hentixp stoul thay undeald mesplit you doferio y ho t hain mact it yo\n",
      "\n",
      "\n",
      "iter :733000, loss:0.073538\n",
      "n ans rofucting ping ith iglyct, and Ptod cacisit domadize ysyrNetoblecturnthing ysyour pouplaw.\n",
      "\n",
      "Thences to understand and maintain if yodendeupling tisur interface, covering every behaviour of the u\n",
      "\n",
      "\n",
      "iter :733500, loss:0.073149\n",
      "plices oug th muct ent shat change coveder cfor of compose woredtiple (Sines ass ot yod and letha le alc if y hove ing pepis lly ithy wode arict be at the roulling mefrass wint freplasy toget endercon\n",
      "\n",
      "\n",
      "iter :734000, loss:0.073186\n",
      " tem that cens on ince that change in toge in text bount ball of mud.\n",
      "\n",
      "We nestand interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It\n",
      "\n",
      "\n",
      "iter :734500, loss:0.072886\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it wict brofer ore rvery bnal\n",
      "\n",
      "\n",
      "iter :735000, loss:0.072895\n",
      "Thxwy that sighly thhing wry cory of the code tha le slout im achingl.\n",
      "\n",
      "The chearcony.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively d\n",
      "\n",
      "\n",
      "iter :735500, loss:0.072673\n",
      "asing loup couply pood thin. Be bapk arcrilly intadize your packag sey he endall-owitiges to clearlese it mucler cont hode ars is entmyocliad of clearly defined boundaries not to leak the domain. The \n",
      "\n",
      "\n",
      "iter :736000, loss:0.072504\n",
      "ed mates tarnoge hergedelitRewet th arges the code that innend. Itsit.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a w.\n",
      "\n",
      "We need a\n",
      "\n",
      "\n",
      "iter :736500, loss:0.072268\n",
      "ss componenes tode and wito such thot ot ysur po maced sigin coundarread wont how much easit ings accendr te ane that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everyt\n",
      "\n",
      "\n",
      "iter :737000, loss:0.072772\n",
      "ctesuss feplencthit. They to ping bo storeacy thhic into and components che urnos together, stays togedin anthith couctth oh thor couplit code ass as do the correctemt, Pnowled ka yout iop mempond ing\n",
      "\n",
      "\n",
      "iter :737500, loss:0.071814\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aur codult ain inount compon mamllible everleceint def contere ta urhe steasis on sect The code that your paen sied oncende. Your pour ive s. Prohit comrocens ing public maditsithin yogene ted. Pviont\n",
      "\n",
      "\n",
      "iter :738000, loss:0.072394\n",
      " inowlec, the centroun ave ingle Iser of inge constowettithinge rofull- erinle ste code thas de bhat thing your code all cod pres ofed iog erpysur ef your arcom thou napr ysur code arcode that th t an\n",
      "\n",
      "\n",
      "iter :738500, loss:0.072349\n",
      "n ans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the tempt\n",
      "\n",
      "\n",
      "iter :739000, loss:0.071884\n",
      "plices oug th muct enthy urLould th unces th wecting on en be entare is together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope y\n",
      "\n",
      "\n",
      "iter :739500, loss:0.071855\n",
      " semare to inte.\n",
      "\n",
      "Then, instead of writing unit tests for every publy bofer er afecous and BasketRepository have in common? Nothing. Both address different problems, so why ghoun aed derreanlew consit\n",
      "\n",
      "\n",
      "iter :740000, loss:0.071473\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :740500, loss:0.071384\n",
      "The basis cuandeclare tefur interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced w\n",
      "\n",
      "\n",
      "iter :741000, loss:0.071123\n",
      "agus wnon tosithy hode are in we damr co intexts pebling arp imat. Bogesinntand overy to learly consists of conpering the domain knogethergrod thew components.\n",
      "\n",
      "Ideally, we should aim for high cohesio\n",
      "\n",
      "\n",
      "iter :741500, loss:0.070848\n",
      "ed mates tarnoge component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion.\n",
      "\n",
      "\n",
      "iter :742000, loss:0.070580\n",
      "ss ale conterfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting oth\n",
      "\n",
      "\n",
      "iter :742500, loss:0.070994\n",
      "ctuprevine ssinn ysur code aro un ansessers cundest fofuntr coref yode ars is e the codely arly cingle, your abley, cthere component depends on orcody trow components.\n",
      "\n",
      "Ideally, we should aim for high\n",
      "\n",
      "\n",
      "iter :743000, loss:0.070005\n",
      "aur incel, inos to cod correctly. your concexts.\n",
      "\n",
      "The stow the coducl, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together\n",
      "\n",
      "\n",
      "iter :743500, loss:0.070508\n",
      " kovedina smaletestioge rodully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the\n",
      "\n",
      "\n",
      "iter :744000, loss:0.070407\n",
      "n ans ofllacents and Basss weting thes thit coupling BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductReposito\n",
      "\n",
      "\n",
      "iter :744500, loss:0.069929\n",
      "plices oug th noucthass.\n",
      "\n",
      "Thengepine lever, defont dur. gemure in wnclind otjone ither coucdes throduraccess mofroble couplid; why ?rkevel, the nests.\n",
      "\n",
      "Whenctoghes common pund contain all classes of a\n",
      "\n",
      "\n",
      "iter :745000, loss:0.069855\n",
      " semanit the component depends on or interasssing mackas ais ia sugesist thing wryoul indede the ssifled ence, and Basinctions froductRepository arly cimplctecterurithings todertin. Tha ses! it tn a y\n",
      "\n",
      "\n",
      "iter :745500, loss:0.069476\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :746000, loss:0.069334\n",
      "The nale ssutherg.pler, and unnt defentar. Botucintict bo comain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What \n",
      "\n",
      "\n",
      "iter :746500, loss:0.069092\n",
      "a we theald yot, as common puclever inte smaller chmactode tory gemponents.\n",
      "\n",
      "Ideall of muThe depestint hingrs fenec and oncepl, anctergh stoblecon thyogrerpos oupund oupler, ingedinte nout aro context\n",
      "\n",
      "\n",
      "iter :747000, loss:0.068795\n",
      "ed mates tarnte. Useane sbapl components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and\n",
      "\n",
      "\n",
      "iter :747500, loss:0.068551\n",
      "ss aup in comedit yoneas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common p\n",
      "\n",
      "\n",
      "iter :748000, loss:0.068955\n",
      "ctecting fseckaurhe nenender ived objects.\n",
      "\n",
      "When suctingly unicg component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, the\n",
      "\n",
      "\n",
      "iter :748500, loss:0.067997\n",
      "e eo isien surnessururg tutkmkou deat diply wit dompon/cemponents, these components will you ha le sicum thrwiclempone thes of wlit if arkald enobleak geveccer. Cohesion is a pretty simple concept, an\n",
      "\n",
      "\n",
      "iter :749000, loss:0.068506\n",
      " inverposunt ouplit indy your pour ive are theucthet correply contain al ted.\n",
      "\n",
      "The pomponender, incode that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything publi\n",
      "\n",
      "\n",
      "iter :749500, loss:0.068422\n",
      "n ans fode toulling mefrs of with other, ong ProductReput. Bothe. Ims oode arict ann suringeptsrertsiand Bospend un common pmaplyinl em on pomponed into ans one codtige clearleses onnes together, da r\n",
      "\n",
      "\n",
      "iter :750000, loss:0.067995\n",
      "pliterith atew. The rach you ncealated.\n",
      "\n",
      "The more restricted your access level, the fewer chancess es ta learn correctly. It is about how much one component depends on or interacts with other componen\n",
      "\n",
      "\n",
      "iter :750500, loss:0.067937\n",
      " ie orgot ences th arroges ances sha dervenler othes th tectsstitose big ghy. Pacr ofrerather commerorpoge froge courd that.\n",
      "\n",
      "The basic summary of theve ysulinesitinelle consit coute that will ine iav\n",
      "\n",
      "\n",
      "iter :751000, loss:0.067616\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :751500, loss:0.067491\n",
      "The complit. Bogetrer of clem accund your to understand and maintain if comply profledremtorsimg ofeectthe tents witu ing toge couter everything public! That is why codebases turn into a mass of inter\n",
      "\n",
      "\n",
      "iter :752000, loss:0.067309\n",
      "a ingar ponur inty aciog ofresta ingerster th ounted bour to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic su\n",
      "\n",
      "\n",
      "iter :752500, loss:0.067038\n",
      "ed mathe oser interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable\n",
      "\n",
      "\n",
      "iter :753000, loss:0.066850\n",
      "ss aur is cothe code that changes together, stays together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependenc.\n",
      "\n",
      "It wige \n",
      "\n",
      "\n",
      "iter :753500, loss:0.067277\n",
      "ctisuratint che tompositiB, andes to y hricomed lachitecthe domain. The rame ssew. \n",
      "Ilerp intarin le testep ed blichancting mute component can be changed or even replaced without impacting other compo\n",
      "\n",
      "\n",
      "iter :754000, loss:0.066366\n",
      "e er ine iaveriet and mall contexts to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code tha\n",
      "\n",
      "\n",
      "iter :754500, loss:0.066893\n",
      " in wotict Basit. Cofwy ubit isimptext frogetReroup th avectiys together, carefully emconth ro sterfer components, these components will inevitably interact with one another, and it will require clear\n",
      "\n",
      "\n",
      "iter :755000, loss:0.066831\n",
      "s an es or esters of the codeves, bent's itRedewit thy. Packages should contain all ans enot and onoged interfaces aud things get much easion to learn correctly. It is about how much ossta ingqumpont,\n",
      "\n",
      "\n",
      "iter :755500, loss:0.066437\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plis maces ave is a sing ore codu access mareere four code tha d mere readdog that ysur the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, \n",
      "\n",
      "\n",
      "iter :756000, loss:0.066391\n",
      " sista ings ofde in ontext arp itheryon. Use well-defined intectRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductSe\n",
      "\n",
      "\n",
      "iter :756500, loss:0.066098\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When softyopeter contere is yos capturt couplif your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository a\n",
      "\n",
      "\n",
      "iter :757000, loss:0.065976\n",
      "The dacessth iounter ofectRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highl\n",
      "\n",
      "\n",
      "iter :757500, loss:0.065818\n",
      "a init todopting coupd one haaling tompode thing tnoull ancess.\n",
      "\n",
      "Thes that things ges tost cou detect.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we c\n",
      "\n",
      "\n",
      "iter :758000, loss:0.065551\n",
      "ed mates through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of gralk hes masy pouplinges oh yogither spacing unit ins lew is wiconttnowiting urhes, s of couthie d\n",
      "\n",
      "\n",
      "iter :758500, loss:0.065385\n",
      "rext important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for howiting ure are somponent corponeake of\n",
      "\n",
      "\n",
      "iter :759000, loss:0.065817\n",
      "y.\n",
      "\n",
      "Thengesitvedy.\n",
      "\n",
      "Thenithere components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundar\n",
      "\n",
      "\n",
      "iter :759500, loss:0.064923\n",
      "auresit mompod com? to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes togeth\n",
      "\n",
      "\n",
      "iter :760000, loss:0.065449\n",
      " poutlyound roly mrag. Bogetrerconcesing tesin wiogy he reforpest, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, st\n",
      "\n",
      "\n",
      "iter :760500, loss:0.065390\n",
      "s dit mund wing bot tour aur cohes.\n",
      "\n",
      "Thes together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays to\n",
      "\n",
      "\n",
      "iter :761000, loss:0.065011\n",
      "plices oug th pout ef orand into inoupled obje us access level, the fewer chances to create unnecessary dependencouply withy iontsitR.\n",
      "\n",
      "Wveryad interface, che ter thinge ssable clearly defintis of cle\n",
      "\n",
      "\n",
      "iter :761500, loss:0.064964\n",
      " in entint pour ind legho jecthou. The conthitg. Bs ro e are is ant ishe sistinll onces th context from conthous the coupder.thit.\n",
      "\n",
      "By pomponent's public interface, covering every behaviour of the uni\n",
      "\n",
      "\n",
      "iter :762000, loss:0.064685\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :762500, loss:0.064555\n",
      "The napests forersines turutin. Tha seskagro understand and maintain if we can effectively draw and enforce boundaries during deveapestrged and overreaching from other contexts.\n",
      "\n",
      "What do ProductReposi\n",
      "\n",
      "\n",
      "iter :763000, loss:0.064410\n",
      "a unit thit componentablit that.\n",
      "\n",
      "\n",
      "Whag the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependen\n",
      "\n",
      "\n",
      "iter :763500, loss:0.064140\n",
      "ed thear tect ta laall focthed bo thitg. Use ithe bo robldes torvict mests frouc im opreacsion your po terk that thow inow tasketRepository have in common? Nothing. Both address diffectnclentide clew \n",
      "\n",
      "\n",
      "iter :764000, loss:0.063988\n",
      "der se is er eve if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code th\n",
      "\n",
      "\n",
      "iter :764500, loss:0.064418\n",
      "y. the todericturkagyopllaw ctur evuricis le th unct bonotheve isig th pompre Nomstoul chive torpess baccexp merr as mmanne tha fechither on stout im or? ung ount contect wing bit suchithoupd abouneco\n",
      "\n",
      "\n",
      "iter :765000, loss:0.063537\n",
      "aur codu the prif yode should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low co\n",
      "\n",
      "\n",
      "iter :765500, loss:0.064060\n",
      " kopemponende, arr contexthone tedrablat endercomplit indes together, stowit covedy packagyoupling. The rofelys, ouplit; whe gomerpore should aim for high cohesion and low coupling. Apply the Single R\n",
      "\n",
      "\n",
      "iter :766000, loss:0.064004\n",
      "s an es compont bact bout yound and enot onnof cent componentiply rode and ka urinnt youjure cod ctur yo make other componentsingit the compricitly into the code. Your code should reflect the architec\n",
      "\n",
      "\n",
      "iter :766500, loss:0.063637\n",
      "plione simpont your pour avent the ilvecting other components.w.\n",
      "The code that serves a commerory paon thew common purpose stays together. Cohesion is a pretty simple concept, and I hope you have unde\n",
      "\n",
      "\n",
      "iter :767000, loss:0.063589\n",
      " semare to intedorPeplye\n",
      "\n",
      "Iverions to ether together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that is with othwrerofle (SRP\n",
      "\n",
      "\n",
      "iter :767500, loss:0.063325\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :768000, loss:0.063190\n",
      "The cammer evap en meverurins fectads to are simy he yh rofunded dhey the domain knowledg. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository a\n",
      "\n",
      "\n",
      "iter :768500, loss:0.063056\n",
      "a init tests fhout todritict your achestrowly proul chatrog fod ofrcompostayse bever contexts together, stays together, cade thouctth os or overcoblay urhe cont in ancomyotRdederacinto y the ievery pu\n",
      "\n",
      "\n",
      "iter :769000, loss:0.062788\n",
      "e yourit in to inte.\n",
      "\n",
      "Tvery prelre chould contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests fo\n",
      "\n",
      "\n",
      "iter :769500, loss:0.062651\n",
      "ss aur the hrog. The codewar bo y homarrempode things get much easier to understand and maintain if your archines.\n",
      "\n",
      "The basic sumabin; Cosind oun en aventa ungegetReposithed to are sucie is ed context\n",
      "\n",
      "\n",
      "iter :770000, loss:0.063083\n",
      "ot components.\n",
      "\n",
      "When software is decomposed into smaller components, the ethergede comrecessiot tage stur of that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything\n",
      "\n",
      "\n",
      "iter :770500, loss:0.062220\n",
      "a ed trot ef ing wly. It all conce taught you. \n",
      "Brerything wices cha hio ghone that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is wnout ind pom\n",
      "\n",
      "\n",
      "iter :771000, loss:0.062744\n",
      " roupling mapill end. Packaml, whe story is that things get much easier to understand and mall sinner of comrodedt if y accenssig togeti-g ith itheer for erabe togetit we arcemarg of component dupl-de\n",
      "\n",
      "\n",
      "iter :771500, loss:0.062697\n",
      "s an lderka er ente, of contexts foricts are code that serves a common purpose stays together. Cohesion is a prethor the component can be changed or even replaced without impacting other components.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :772000, loss:0.062346\n",
      "pliceexts.\n",
      "\n",
      "It's essentisull require clearly defined boundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the\n",
      "\n",
      "\n",
      "iter :772500, loss:0.062304\n",
      " semor, youly overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductSe\n",
      "\n",
      "\n",
      "iter :773000, loss:0.062057\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :773500, loss:0.061924\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The basicles on coun ofwet en to inte.\n",
      "\n",
      "The ba k somponenden, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, cover\n",
      "\n",
      "\n",
      "iter :774000, loss:0.061808\n",
      "agus wnon tod other of re behac into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific domain/context and only pr\n",
      "\n",
      "\n",
      "iter :774500, loss:0.061547\n",
      "ed maty Coup them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access leved, and enfors and puppould yonising os of ces out ind pemabo \n",
      "\n",
      "\n",
      "iter :775000, loss:0.061427\n",
      "ss cumpoupled to enonecthy de the Single Responsibility Principle (SRP) for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfac\n",
      "\n",
      "\n",
      "iter :775500, loss:0.061866\n",
      "ctecturple yopregeasurg big su h aen mert.\n",
      "\n",
      "The basic suwliogetReratints are the components clearr hould be capturing the domain knowledge in working code and protecting that knowledge in your context\n",
      "\n",
      "\n",
      "iter :776000, loss:0.061021\n",
      "aur codulis ents and in ther ose it pourp cenne stay arlaces complery and main mpundederyrion tsie dimg to inore component depends on or interacts with othwions madl-definew tha gepes the domain knowl\n",
      "\n",
      "\n",
      "iter :776500, loss:0.061554\n",
      " koveding pully endint desinges to contexts.\n",
      "\n",
      "The bos cod ange in tucill thingy Nomain knot tonlercoblia thit contain ald interconnections across components. It means one component can be changed or e\n",
      "\n",
      "\n",
      "iter :777000, loss:0.061519\n",
      "t arsessemut, prot ys entsil/ion or andems, coduine pain is wite corges cimple concept, onery peasion to understand and maintain if we can effectively draw and enforce boundaries during deveapreverer \n",
      "\n",
      "\n",
      "iter :777500, loss:0.061185\n",
      "plices our coupderkcti\n",
      "\n",
      "\n",
      "The pomponents tne fewer changes tn of cing component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components,\n",
      "\n",
      "\n",
      "iter :778000, loss:0.061153\n",
      " semare rodully endara sime ande aring mals ontext and only provide access to other packages turp your architectural ideas ably code ald pura simg oho yoserats.\n",
      "\n",
      "Whe basicles masess onte inique innes \n",
      "\n",
      "\n",
      "iter :778500, loss:0.060923\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smam th yourextseapest, bound blic! That inde she erveracosyogebuf your acoup th we they theviog inges ofs. knoun\n",
      "\n",
      "\n",
      "iter :779000, loss:0.060802\n",
      "The compon mamponents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the \n",
      "\n",
      "\n",
      "iter :779500, loss:0.060702\n",
      "a init todup if yog overy packaut hew is we fowlecontings to mare or ther coductRepompode th ingeble po pomung.\n",
      "\n",
      "The coderacs.\n",
      "\n",
      "The basic summary together, carefully encapsulated.\n",
      "\n",
      "The more restricted\n",
      "\n",
      "\n",
      "iter :780000, loss:0.060465\n",
      "ed mates tarnoge concers, wrine to with will to oh cohes.\n",
      "\n",
      "The pomeracsextricly penende. Yowecres cimhonen mequade tays tode todepine difey to clats could arching from other contexts.\n",
      "\n",
      "What do Product\n",
      "\n",
      "\n",
      "iter :780500, loss:0.060365\n",
      "ssiog ing la s munt Pa bigen mefine th you h aentsice to mefend ablerg is mumall-dedrraprext pould are istays todull-defined purpone the code. Your code should reflect the architecture diagrams that y\n",
      "\n",
      "\n",
      "iter :781000, loss:0.060837\n",
      "y.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout my article\n",
      "\n",
      "\n",
      "iter :781500, loss:0.060040\n",
      "aur cout im on? Nothy shans to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that change\n",
      "\n",
      "\n",
      "iter :782000, loss:0.060660\n",
      " kom omakn kf you doppesisif cour interfaces and inversion of control for ligh cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnectio\n",
      "\n",
      "\n",
      "iter :782500, loss:0.060792\n",
      "t domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unill ind macturkagyosstay. \n",
      "fhecoms.\n",
      "\n",
      "Ther aferecisilg is for every bund inealed.\n",
      "\n",
      "We \n",
      "\n",
      "\n",
      "iter :783000, loss:0.060583\n",
      "plices oug cain all oncept, yould or expour placed maturkepinteracthet ofrompondrorkagle cthe cofuld ghoferting mack more readable. The name of such components clearly announces their purpose, and suc\n",
      "\n",
      "\n",
      "iter :783500, loss:0.060788\n",
      " semany seasitsiogempode thy ur changede aon inversion as to leak the domain. The resulinit do bacy.\n",
      "\n",
      "The basic summary of the slout imuth components clearl cour compone anferext mCompothe things get \n",
      "\n",
      "\n",
      "iter :784000, loss:0.060675\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :784500, loss:0.060757\n",
      "The componentsiall in cound of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every cla\n",
      "\n",
      "\n",
      "iter :785000, loss:0.060729\n",
      "a inia d surhes encef wuth ed or evingr ples math Nomain knoullea lit how oup in your coduct bouther enecthes together, stays tuge nont, and Product bouther estry. Ppunats obutinn abounessiontist da y\n",
      "\n",
      "\n",
      "iter :785500, loss:0.060631\n",
      "ed maty Coup thamu sic ive th the nome context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and Baskltstracs together, carefully encapsulated.\n",
      "\n",
      "The more restrict\n",
      "\n",
      "\n",
      "iter :786000, loss:0.060570\n",
      "ss components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. \n",
      "\n",
      "\n",
      "iter :786500, loss:0.061135\n",
      "y.\n",
      "\n",
      "Coup ied wing oftonlall onctarl-de w arcomrore arly cing your to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :787000, loss:0.060329\n",
      "aur iribge steat youp compot pacthesion ant dode thawiting umpontaning mtogether?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code t\n",
      "\n",
      "\n",
      "iter :787500, loss:0.060960\n",
      " roupling m aple is a sa is lew in Cot comeepthe sterpesthe homainge compone the sis susind of cleasis on your cohesini no pode t, wer itRected objects.\n",
      "\n",
      "It's essentict tull-defin we the component's p\n",
      "\n",
      "\n",
      "iter :788000, loss:0.060988\n",
      "t domally chacted abem iagle story is th ackasisuly inceplasisss compone masy po code th ark ach monesss of yot andes to codgemkourhiner thever enderfaces oup in ents ant to eng ange comer correspllr \n",
      "\n",
      "\n",
      "iter :788500, loss:0.060666\n",
      "plity tod yout mmow. Chaclerand much more reand abot eve und ure codg that thing cleare simple concept, and I hope you have unneces ancess mabnses our ia ur are code to ane kasy to torreaistror change\n",
      "\n",
      "\n",
      "iter :789000, loss:0.060670\n",
      " semlring madi makifrerrapy evines avellriendes tnol the them? Componesit. Thempont cody troul context from contamination and overreaching from other com coductRerontect, wuonteraous the about highly \n",
      "\n",
      "\n",
      "iter :789500, loss:0.060437\n",
      "or even replaced without impacting other component depents and ctompodethru. gepl-deraclesting Baskesitive lay urithacsing \n",
      "freracrext ingrut wo iaghog ohet inte, that will end up in a big ball of mud\n",
      "\n",
      "\n",
      "iter :790000, loss:0.060347\n",
      "The componentint your to und correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing\n",
      "\n",
      "\n",
      "iter :790500, loss:0.060253\n",
      "a ungaly sumain ys fure cha stRep argesitu hsuge testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces th\n",
      "\n",
      "\n",
      "iter :791000, loss:0.060023\n",
      "e yhare readaintes ably entares wit domala mon? Nothed that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into t\n",
      "\n",
      "\n",
      "iter :791500, loss:0.059913\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ss ata ingw togetill your to understand and maintain if we can effectively draw and enforce boundaries during dequa simklher aceasith othwiting bes capo incould oup ingqul ances th your to lrayla evid\n",
      "\n",
      "\n",
      "iter :792000, loss:0.060390\n",
      "y. Use wally itof reys, und andeconthe component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we sime thacter it your to learn correctly. It is about how much one component depends on or i\n",
      "\n",
      "\n",
      "iter :792500, loss:0.059533\n",
      "aures common puap dully we insion intorelit. Bothout im oth ouctsew together, carefully encapsulated.\n",
      "\n",
      "The more re coverves tegefier ciaply tohices suctss, domain knowledge in working code and protect\n",
      "\n",
      "\n",
      "iter :793000, loss:0.060099\n",
      " ithents a ingess componenaass.\n",
      "\n",
      "Wha ing gmak the gempone, and such asurnes together, de arf canc codut, Prode anceit yodettot ore are cody to orkevedg that knowledge in your contexents com ourpend on\n",
      "\n",
      "\n",
      "iter :793500, loss:0.060058\n",
      "t domally.\n",
      "\n",
      "The come fecis ingebllasss fur things wept tould be capturing thergetilly thew inhe tha ges ro pestlif compos le arcould uas esur to understand and maintain if we can effectively draw and \n",
      "\n",
      "\n",
      "iter :794000, loss:0.059721\n",
      "plicext, wubit inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacthed that will e\n",
      "\n",
      "\n",
      "iter :794500, loss:0.059678\n",
      " sista ings mple iste boundar encepl, ancterand or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact wit\n",
      "\n",
      "\n",
      "iter :795000, loss:0.059431\n",
      "or even replaced with unun asitlyose nog thet.\n",
      "\n",
      "Thecterte\n",
      "nteratss.\n",
      "The code the inewit depasissicsit tayly suplis ing depreris wectestebleay hif youp arcompinter mam? acuer into ans os coutinn.\n",
      "\n",
      "The \n",
      "\n",
      "\n",
      "iter :795500, loss:0.059307\n",
      "The napestint ielt is to steasisif cemposedts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveap\n",
      "\n",
      "\n",
      "iter :796000, loss:0.059200\n",
      "anled. Both acosysply he th uner concerperves a common pued ances. Use it pmacto yos cury pe coved thing to urabgextser of a specific domain/contexts.\n",
      "\n",
      "The basic summary of the story is that things ge\n",
      "\n",
      "\n",
      "iter :796500, loss:1.052506\n",
      "ed pound blic!c. nogederreanating be ror highleats.\n",
      "\n",
      "Weatr context from contamination and overreaching from other contexts.\n",
      "\n",
      "Wow yoreper thaw untectReat thin. Itsewitint couthin. \n",
      "Cogedars out thewitu\n",
      "\n",
      "\n",
      "iter :797000, loss:2.716160\n",
      "ss cor h aen me ances th ack beverg\n",
      "\n",
      "The rout po nod your to learn correctly. It is about how much one cofinig thy. It wit siag tint your to understand and maintain if we can effectively draw and enfo\n",
      "\n",
      "\n",
      "iter :797500, loss:2.355718\n",
      "y.\n",
      "\n",
      "Countibly inobrecteracinde things wectes esser thew components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use w\n",
      "\n",
      "\n",
      "iter :798000, loss:1.638504\n",
      "aur indall-deprevigit to leak the domain. The result is a system that consists of cooperating but independent, bounded conter I ferea eraisic tha sim! That is why codebases turn into a mass of interco\n",
      "\n",
      "\n",
      "iter :798500, loss:1.084971\n",
      " pouth ano contextsinle (SRP) for high cohesion. Use well-defined interfaces and inversiont is the corr iene der rouplid. Thew theckout mos file ender, you to understand and maintain if your architect\n",
      "\n",
      "\n",
      "iter :799000, loss:0.726174\n",
      "s ant depo ieveructhes, cther to learntis will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result tad s arp inge. Yopung on the com\n",
      "\n",
      "\n",
      "iter :799500, loss:0.503625\n",
      "plic mross, we ianle components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists\n",
      "\n",
      "\n",
      "iter :800000, loss:0.366007\n",
      " ineas essebteccont. Pay, ances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a\n",
      "\n",
      "\n",
      "iter :800500, loss:0.279846\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When sof code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupli\n",
      "\n",
      "\n",
      "iter :801000, loss:0.224437\n",
      "Textsit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to of roopes oup coupderkcti\n",
      "\n",
      "\n",
      "The pont code is wet indy ton ederais a sts aved objects.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :801500, loss:0.186199\n",
      "adu he rome, and un and I ompend baus toductService, and ProductRepository are highly coupled; why would newg plite, and ProductRepood things wetill monot effectively draw and enforce boundaries durin\n",
      "\n",
      "\n",
      "iter :802000, loss:0.161769\n",
      "ed mount tabl defont in ant in if yod overy paykages th w components.\n",
      "\n",
      "Idealle Rerres simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn\n",
      "\n",
      "\n",
      "iter :802500, loss:0.143296\n",
      "ss curpore arf cof cann constings entertint caplesin st oned pore re four co inountituctint, and ut wain if y hove is ofponde.\n",
      "\n",
      "Then, it ave intext, wurion consists of yowitill more re costing os mari\n",
      "\n",
      "\n",
      "iter :803000, loss:0.131307\n",
      "y.\n",
      "\n",
      "Coupnextring ysur code arcene. Cofecimto maces sumponects.\n",
      "\n",
      "Wve y. Puld and pengs ofteris were hest, and Basinctions ProductRepository are highly coupled; why would not you group them? Cohesion - \n",
      "\n",
      "\n",
      "iter :803500, loss:0.120399\n",
      "e everuring the code thy urict productReptentsting ysur code ant in wotict your to orke. Yommptint ithet wind and much more readable. The name of such components clearly announces their purpose, and s\n",
      "\n",
      "\n",
      "iter :804000, loss:0.114106\n",
      " pourncous ahr context amutire canselin. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling besising unit mes will, interface.\n",
      "\n",
      "Then, instead of writing unit tests fo\n",
      "\n",
      "\n",
      "iter :804500, loss:0.108170\n",
      "t domain/context and ones to und unict maon control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impac\n",
      "\n",
      "\n",
      "iter :805000, loss:0.103752\n",
      "pliceexts.\n",
      "\n",
      "Ie's mary bestrale ither? on wey momecos engqumpos sucl, anl components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get mu\n",
      "\n",
      "\n",
      "iter :805500, loss:0.100024\n",
      " siflcom tho gfullancturnog that thoun thenctderacs of wrackagyoup int ot athes together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chane dompos oup murghe that your po\n",
      "\n",
      "\n",
      "iter :806000, loss:0.096850\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :806500, loss:0.094291\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devilly to evend ass wogethins beverais to un encede t\n",
      "\n",
      "\n",
      "iter :807000, loss:0.091682\n",
      "anl of madd ound po po? shentict publing ure the component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components wi\n",
      "\n",
      "\n",
      "iter :807500, loss:0.089614\n",
      "ed mates tarnoge concery hould be capturinis riall context important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we s\n",
      "\n",
      "\n",
      "iter :808000, loss:0.087583\n",
      "ss wit is toge com uckag erporaced wind and overreacinte your te ancemarged pofrethem thatr compoulling! That is why codebases turn arctinntiol and encept torrectly. It is about how much one component\n",
      "\n",
      "\n",
      "iter :808500, loss:0.086595\n",
      "y.\n",
      "\n",
      "Couple ofed of com out todr contexts.\n",
      "\n",
      "What doppesind objectsyopestr context from contamination and overreaching froour porpen th u ghmur.\n",
      "\n",
      "The contexts.\n",
      "\n",
      "What code that will end und r acracle ara\n",
      "\n",
      "\n",
      "iter :809000, loss:0.084283\n",
      "e encept torrectly. It ive clearly of yoopesiog oh thecoble ithe sinntes turpode ars a ProductRepository are highly couplinge nonend ur in inged thine damkt Coundell-defin we insint ra e amuthe depend\n",
      "\n",
      "\n",
      "iter :809500, loss:0.083741\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " koveding pompone andeplaseer ancept tore, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "T\n",
      "\n",
      "\n",
      "iter :810000, loss:0.082466\n",
      "d ar es copth isng und kasur The code tast isill The pomponenes comhonents.\n",
      "\n",
      "Ideally, we ssstrape reasingr chilg understand and maintain if we can effectively draw and enforce boundaries during devin \n",
      "\n",
      "\n",
      "iter :810500, loss:0.081271\n",
      "plicee thy pould menis. Prohinces to congeflect tainc suth estacsiog erore conceptorentspar copmersy ofunted rous to und thay ounded wericts sicum thou cham oses the dodectforit yound andecontasss one\n",
      "\n",
      "\n",
      "iter :811000, loss:0.080422\n",
      " simpo the codest, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code shoul\n",
      "\n",
      "\n",
      "iter :811500, loss:0.079423\n",
      "or even replaced without impacting your code ant in cotull-dere rhances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything p\n",
      "\n",
      "\n",
      "iter :812000, loss:0.078783\n",
      "Thengepteg th a your arcour chath ange itveduring the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do P\n",
      "\n",
      "\n",
      "iter :812500, loss:0.077830\n",
      "all caur togrer avedy anctnes togetisram? Notings a che fontrechavery boms, compon mable simpodunt the temuthw, yonen. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupl\n",
      "\n",
      "\n",
      "iter :813000, loss:0.077086\n",
      "ed mates tarnted cont code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up \n",
      "\n",
      "\n",
      "iter :813500, loss:0.076222\n",
      "ss wit thiog thectlrult fouply hrog ay to witextsi\n",
      "\n",
      "she bos th is fepensy. \n",
      "Couple comurg puning mars togethargh concess, bof rew changes to y urkaus todully Ihas onglit.\n",
      "\n",
      "Compon isige e ithercobly co\n",
      "\n",
      "\n",
      "iter :814000, loss:0.076204\n",
      "y.\n",
      "\n",
      "Countably wit mectederthe Single Re bour kounted tour code arn tint cofply and in ansing from orgefit code all isic.\n",
      "\n",
      "By not ing or ined therelconceas torrectleals compon isimple isveriot yogit do\n",
      "\n",
      "\n",
      "iter :814500, loss:0.074731\n",
      "e evernountsilliog thec.\n",
      "\n",
      "Thencoblyowit cofuctand The naply or centkouness, lo y trie yoseats coupes cuer interfaces and inversion teererint Your pout ive ale ssecrork the domain knowledge in working \n",
      "\n",
      "\n",
      "iter :815000, loss:0.074934\n",
      " pourncoune hode alk ither components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that co\n",
      "\n",
      "\n",
      "iter :815500, loss:0.074306\n",
      "s an ysstonlexks of yo componenes.\n",
      "\n",
      "Thenglang ohether. Cohesion istous ted satReaid mectsinize torrectinn ande thit control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across componen\n",
      "\n",
      "\n",
      "iter :816000, loss:0.073663\n",
      "plicee cha rouldoblems, s of wrecous te oraced wh oupone ssimpong fo ehoupling. Apply the Single Resting ysur iflyounderpes? Checcont.\n",
      "\n",
      "The basic summary of the story is that things get much easier to\n",
      "\n",
      "\n",
      "iter :816500, loss:0.073250\n",
      " components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundcowe ithar es compoutncta unie d\n",
      "\n",
      "\n",
      "iter :817000, loss:0.072632\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :817500, loss:0.072306\n",
      "Then that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize y\n",
      "\n",
      "\n",
      "iter :818000, loss:0.071734\n",
      "a insingque sunnctiobed intersing that csion of capresis surint oved if youthing frempoduraciste anise components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitabl\n",
      "\n",
      "\n",
      "iter :818500, loss:0.071280\n",
      "ed matess, wogest, wing oh weduring the ather of o uapees annted.\n",
      "\n",
      "The rou nedy and leare simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to l\n",
      "\n",
      "\n",
      "iter :819000, loss:0.070760\n",
      "ssiour highly coupled orut ine sintty bous e dearcod cors access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit t\n",
      "\n",
      "\n",
      "iter :819500, loss:0.070994\n",
      "ctestersinges together, cale itvergesing unit testryint, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays togeth\n",
      "\n",
      "\n",
      "iter :820000, loss:0.069825\n",
      "e encept corcody trour context from contamination and overreaching frog oreersiontistada is werte sthout one, orrore and pund contr.\n",
      "\n",
      "ghenincess, write unit tests focusing on the component's public in\n",
      "\n",
      "\n",
      "iter :820500, loss:0.070243\n",
      " pourncons component can be changed to arkh cemmonctestoblay etvind onct yos siad the nometage ting the domain knowledge hing componed boundaries fof such ampone tabley comeduritint compone, and such \n",
      "\n",
      "\n",
      "iter :821000, loss:0.069880\n",
      "s an es the next ing your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context fro\n",
      "\n",
      "\n",
      "iter :821500, loss:0.069422\n",
      "plit w. The napr ass ot coo eters bllac. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such com\n",
      "\n",
      "\n",
      "iter :822000, loss:0.069235\n",
      " inew, to thare ts wild ilg on. ges toduct componented rore ts or you houbling llewlit itRewited. Pacrisnos to cleare nealy he arcemary couplid; why would not you group them? Cohesion. Use well-deflet\n",
      "\n",
      "\n",
      "iter :822500, loss:0.068793\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitablint cod touthings get much easier to understand and maintain i\n",
      "\n",
      "\n",
      "iter :823000, loss:0.068638\n",
      "The cont arpondemta y hod lall oucth arp ithesion we undesst, ing thergede ithery fommencos for overrofled. Papr ass o a surhesitReccempone, andu.\n",
      "\n",
      "Then itot acunc and maintain if your architectural i\n",
      "\n",
      "\n",
      "iter :823500, loss:0.068267\n",
      "agus wnon to inone hapl components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inver\n",
      "\n",
      "\n",
      "iter :824000, loss:0.067976\n",
      "ed mates throug. \n",
      "Coupling ull components, thes together, carefully encapsulated.\n",
      "\n",
      "The more res muctReptsiou dee shaw cope iout he th the compot pacthesion and low coupling. Apply the Single Responsio\n",
      "\n",
      "\n",
      "iter :824500, loss:0.067652\n",
      "ss cur round thewly cingrextswen? together, cant? toduct wabit inverteblayk the next important thing your coduct Prill compocedent torreconiss wore cive testing\n",
      "\n",
      "Components with a single, well-defined\n",
      "\n",
      "\n",
      "iter :825000, loss:0.068030\n",
      "y.\n",
      "\n",
      "The bacr th for every puplind rowe com has de the acsing yshereccounain me, your archings orcend or fod conness once taught you. Inomponbof your architectural ideas map explicitly into the code. Y\n",
      "\n",
      "\n",
      "iter :825500, loss:0.067070\n",
      "e er inverurcter that comyould not you group them? Cohesion. Use well-defin the Single Restfwonglit much rest, and Baske Ropl- sle Ropesion. User of ing. The nonender iply turing ysur yogyoug.\n",
      "\n",
      "The co\n",
      "\n",
      "\n",
      "iter :826000, loss:0.067636\n",
      " kavedy problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together\n",
      "\n",
      "\n",
      "iter :826500, loss:0.067507\n",
      "s an ysstobleain if your archings orcess more reat things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture\n",
      "\n",
      "\n",
      "iter :827000, loss:0.067180\n",
      "plited thingyoget. Proppest, mount bas entents.\n",
      "\n",
      "Ideall of mutice. Yomplie the ghigg ot cod and maintain if your arcuint iog theate, wur ac inte codmextsin tomp context frouplither, ing dill the isten\n",
      "\n",
      "\n",
      "iter :827500, loss:0.067209\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " in entarill arect mapk dicichatly.\n",
      "\n",
      "Low couply.\n",
      "\n",
      "Then, instead of writing unit testryint, and it your aor components, these components will inevitably interact with one another, and it will require c\n",
      "\n",
      "\n",
      "iter :828000, loss:0.066903\n",
      "or even replaced without impacting other component depends on or interacts with other componentsith on towethed of wricles ont if yout int your access level, the fewer chances to create unnecessary de\n",
      "\n",
      "\n",
      "iter :828500, loss:0.066893\n",
      "The basic summary of the story is that things get much easier to understand and maintain if wed of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then\n",
      "\n",
      "\n",
      "iter :829000, loss:0.066646\n",
      "a ungar fors ancod durl inte sine to iner to bith other nout and worgesitvedyopleace ssim acen surlricturing unill is code things get much easier to understand and maintain if your ion sicud th a stak\n",
      "\n",
      "\n",
      "iter :829500, loss:0.066424\n",
      "ed maty Coup thay doup thy contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if ll one her compled. Papr Checkans toge corende ore hray aring the Sing\n",
      "\n",
      "\n",
      "iter :830000, loss:0.066193\n",
      "ss corplerate overacs objects.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to l\n",
      "\n",
      "\n",
      "iter :830500, loss:0.066616\n",
      "y. Use wely commenorpess, domala morie the inowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "\n",
      "Then ave snoup th woule the chantiog theak tes theaistedy public method \n",
      "\n",
      "\n",
      "iter :831000, loss:0.067056\n",
      "a erabgem ore tha sumklle, maprext in all code the componend pomponent depgit your archice co to meviont the component dout code as t pofievery public method of every ur tout a rhail iog ofur coduct b\n",
      "\n",
      "\n",
      "iter :831500, loss:0.859121\n",
      " pourhand components.\n",
      "\n",
      "Ideare, atha yhesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined intectur as components. It maon of besiont torethe ton\n",
      "\n",
      "\n",
      "iter :832000, loss:1.073875\n",
      "t domally ha geve ande worennico le fef yod and llasses of a specific domain/context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in co\n",
      "\n",
      "\n",
      "iter :832500, loss:1.061963\n",
      "plity todull-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story i\n",
      "\n",
      "\n",
      "iter :833000, loss:0.822690\n",
      " tfowit yode and in ohinterface, che tha izeve lentictemtonplicles math and lealy sithyour kogewrertorecosponsibpe should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that y.\n",
      "\n",
      "The basic \n",
      "\n",
      "\n",
      "iter :833500, loss:0.583954\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :834000, loss:0.411525\n",
      "The basictes of controf y hove siot of medreplapke com ofullang macodrepriog of couthing freplices thrcomy thit components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single\n",
      "\n",
      "\n",
      "iter :834500, loss:0.298473\n",
      "agle to together mompone sseare not capued chit and coplectndelereckally urit much tempod otjes clans ouj yosuris depthew. Rewer acone composed inde thath cematidB rect bou nacince that will end up in\n",
      "\n",
      "\n",
      "iter :835000, loss:0.228648\n",
      "ed mates tarnoge concer should be capturing thes, stxt and inoull asind onctReatesting feags is alget components.\n",
      "\n",
      "Ideally, we snous the ion eat texts foduct, ProductService, and ProductRepository are\n",
      "\n",
      "\n",
      "iter :835500, loss:0.186582\n",
      "der! That will ine ise is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your arc\n",
      "\n",
      "\n",
      "iter :836000, loss:0.161753\n",
      "y. Use wall onces to or every punn- ull fawit domallyconserthice lang opued andout conce tout hew ind lew coupling. Apply the rhat yss.\n",
      "\n",
      "Weene is metRins ontexthet, mpoqued shatlyode thy urict mangess\n",
      "\n",
      "\n",
      "iter :836500, loss:0.140994\n",
      "e contain ald Prod corresint, yout pout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code s\n",
      "\n",
      "\n",
      "iter :837000, loss:0.128576\n",
      " roupling bo ka unged of ing.\n",
      "\n",
      "They woup the. The namp ceatively draw and enforce boundaries during devicitly cone that will end up in a bou pue and mevery innare ithes, stayse bog one ibvecting on su\n",
      "\n",
      "\n",
      "iter :837500, loss:0.118411\n",
      "s ans lout imit rhe yoneat hrop simple is aly to are simpode thaul th uritric wit mucling that componed into smaller components, these components.\n",
      "\n",
      "It's essential to organize your packages correctly. \n",
      "\n",
      "\n",
      "iter :838000, loss:0.111429\n",
      "plitees fle bouncofing und components.\n",
      "\n",
      "Wextribly bnhaves will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that \n",
      "\n",
      "\n",
      "iter :838500, loss:0.106212\n",
      " siot capisig tha seableapy ublich dout code is a single, surpone, ath coutinly th wecti\n",
      "g ore he rog che simuct dewing on the story is that things get much easier to understand and maintain if we can\n",
      "\n",
      "\n",
      "iter :839000, loss:0.101808\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require covect, Produ\n",
      "\n",
      "\n",
      "iter :839500, loss:0.098795\n",
      "The nterat thea she nouth oh thou dupinis to learn correctly. It is about how much one component depends on or interacts with other components. It means one component can be changed or even replaced w\n",
      "\n",
      "\n",
      "iter :840000, loss:0.095589\n",
      "all conthe surlit is make to in amponects.\n",
      "\n",
      "Whe bain if your architest, writedd ancterothe the undade onot effective ta togethor toe sto learlarges timp sur ing wroductService, and ProductRepository a\n",
      "\n",
      "\n",
      "iter :840500, loss:0.093330\n",
      "ed mathe oset componthrobintle Restowither esurkaunecose covedirg rig y hever into lace. Yogl-delef or evarit. Bo oraced shepuctleare and It isiale eves, youthorit yode arvery behaviour of the unit. C\n",
      "\n",
      "\n",
      "iter :841000, loss:0.090777\n",
      "ssiogr ciaplit chit components.\n",
      "\n",
      "Ideally, we should aont evisit. Csecouptarne leas the inewit proble simrectinto a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. \n",
      "\n",
      "\n",
      "iter :841500, loss:0.089700\n",
      "y.\n",
      "\n",
      "Coud ore thess, system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effective\n",
      "\n",
      "\n",
      "iter :842000, loss:0.087138\n",
      "e encept cour pouply are is er if y to clatnain mums ond wall onct bo esiond are ing.\n",
      "\n",
      "The rontext from cout imuplycodeet components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply \n",
      "\n",
      "\n",
      "iter :842500, loss:0.086924\n",
      " roupling pofpes our in thes, statres components.\n",
      "\n",
      "Idealioge concept, and fo ghe pould not ance tode tha in coth in weat the component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we shoul\n",
      "\n",
      "\n",
      "iter :843000, loss:0.086025\n",
      "dill, inced your archings get much easier to understand and maintain if we can effectively draw and enforce boundaries during deving cturkagewreve iste basicessinged or even replaced without impacting\n",
      "\n",
      "\n",
      "iter :843500, loss:0.085257\n",
      "plited toba enceplans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that wo khould contais and maintain if your archite\n",
      "\n",
      "\n",
      "iter :844000, loss:0.085065\n",
      " siot ince mary sualle laise tompones cofpes couc! your to orke. ghext is. The code to togrerpos ont horothe sseapetherstous meraly he should contain all classes of a specific domain/context and only \n",
      "\n",
      "\n",
      "iter :844500, loss:0.084417\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components,, wrould your code aly ithe am r amucting the domain knoundefer oncery ur chagro rampone the c\n",
      "\n",
      "\n",
      "iter :845000, loss:0.084154\n",
      "The nace yout ho that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big b\n",
      "\n",
      "\n",
      "iter :845500, loss:0.083265\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "agutionda w the dempor mervene dewer components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a syst\n",
      "\n",
      "\n",
      "iter :846000, loss:0.082864\n",
      "ed mates tarnoge conce taught you. Inot to layrecouR thit. why componenta sim\n",
      "Precting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact\n",
      "\n",
      "\n",
      "iter :846500, loss:0.081924\n",
      "ss components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not toge smasstr if your\n",
      "\n",
      "\n",
      "iter :847000, loss:0.082268\n",
      "ctes marg of clearly components ances th w. ponents comurconthy dompest, wubiteratsskbonse concepts once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protectin\n",
      "\n",
      "\n",
      "iter :847500, loss:0.080938\n",
      "e gopurkagy pompon/cortint Ba sict your accend it thle that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of int\n",
      "\n",
      "\n",
      "iter :848000, loss:0.081749\n",
      " roupdy ubjuct bonot ery. Ptofrot components.\n",
      "\n",
      "Ideally, we should aim for howitucts.\n",
      "\n",
      "When software is tacy togethar, syoun momabage concept, yogesi-g our code that thing yout icly are highog tu ly bo\n",
      "\n",
      "\n",
      "iter :848500, loss:0.081777\n",
      "t domally.\n",
      "\n",
      "The basictestracs of wrickages that commPacid lew couputh orit ino components.\n",
      "\n",
      "When software is decomposed into snouns fontrowiting ysur code arp in wotive le raykages correctly. Packages\n",
      "\n",
      "\n",
      "iter :849000, loss:0.081656\n",
      "plityesistewyt, undefllcom oogeth and code thot cably pmacassease Nong im othe surlither ifeysthat componed interfaces and inversiog feficthcext empostnna ine it wapl isit.\n",
      "\n",
      "The bess a make ever, defa\n",
      "\n",
      "\n",
      "iter :849500, loss:0.082241\n",
      " siot fode that will end up in a big ball of mud.\n",
      "\n",
      "We he enteracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) fo\n",
      "\n",
      "\n",
      "iter :850000, loss:0.082333\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When softwitempty.\n",
      "\n",
      "The comala, the fower on the component's public interface, covering every behaviour of the unit. Checkout my article about eff\n",
      "\n",
      "\n",
      "iter :850500, loss:0.083193\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :851000, loss:0.083545\n",
      "a inia is edturpomare ts with acs.\n",
      "\n",
      "Coerasss ot ef rabl oned tounted that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map exp\n",
      "\n",
      "\n",
      "iter :851500, loss:0.084600\n",
      "edy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve wsig the nependederatid. The nometontexl-de\n",
      "\n",
      "\n",
      "iter :852000, loss:0.119441\n",
      "esiond with Probje tha y he rech acly.\n",
      "\n",
      "The code acmacle mery codvery.\n",
      "\n",
      "Coupling is the nepleace stossind ont yoge component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for \n",
      "\n",
      "\n",
      "iter :852500, loss:0.673463\n",
      "ctestoonetsefwing ont deplacsess massesssiwge remta s acsing ysur code as beginners framework tutorials once taught you.\n",
      "\n",
      "By noptext from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepositor\n",
      "\n",
      "\n",
      "iter :853000, loss:0.845740\n",
      "e ercode components.\n",
      "\n",
      "When softracse blive tohe bout im ofgroons boved components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to lea\n",
      "\n",
      "\n",
      "iter :853500, loss:0.590823\n",
      " roupling poflect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more \n",
      "\n",
      "\n",
      "iter :854000, loss:0.411664\n",
      "t deat impwithen stay ande thit contader avent things to knonlethod commof cait youkh muctss, bout im oh theve ithe boundaries during deveckande tade th wacs togetser the surget promrties simplle ba i\n",
      "\n",
      "\n",
      "iter :854500, loss:0.297837\n",
      "plityes.\n",
      "\n",
      "\n",
      "Low ino pompos ait code and ia ininle thmala ercem ouples sout we hay urithitexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, \n",
      "\n",
      "\n",
      "iter :855000, loss:0.226974\n",
      " siste fout is wiy public your contextsinle te inore correctlears abores onterad texts fectinlliw the fodented raced wit watesting ysur code and protecting fo e com rhay diffycopteras will ing blevell\n",
      "\n",
      "\n",
      "iter :855500, loss:0.182350\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :856000, loss:0.154555\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is anse ither stays together. The code. Your code\n",
      "\n",
      "\n",
      "iter :856500, loss:0.135820\n",
      "agle licging Ba ercecos.\n",
      "\n",
      "Thene, boundade bege seros Praovery public method of every clas lowilll weviog oupling ur indere components.\n",
      "\n",
      "When software is decomposed into smaller components, these compo\n",
      "\n",
      "\n",
      "iter :857000, loss:0.124354\n",
      "ed maties and maintain if wlective tsstopresing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do Pro\n",
      "\n",
      "\n",
      "iter :857500, loss:0.115891\n",
      "ss adraorexd monnterrobunt. Proftextr mpind. keve cha coductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, \n",
      "\n",
      "\n",
      "iter :858000, loss:0.111888\n",
      "cterros contain ald yonent or the acour pompote, that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the cod\n",
      "\n",
      "\n",
      "iter :858500, loss:0.107067\n",
      "e gomponents.\n",
      "\n",
      "Ideally, win in if yracse bog wma. It mann cones to undessting sifleraysion are cofreat and our arint tumpthe se. Your components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coup\n",
      "\n",
      "\n",
      "iter :859000, loss:0.105587\n",
      " pored context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in commonges encef withe archit comarcepdurind ractly. It yshorethers make \n",
      "\n",
      "\n",
      "iter :859500, loss:0.103126\n",
      "s dill inevitably interact with one another, and it will require clearly defined boundapuedine singed of writ code and protesta sigh yout howicgestod ctur cfic youp ies conter evedg or evecka e hod la\n",
      "\n",
      "\n",
      "iter :860000, loss:0.101020\n",
      "pliteer intory urgige ungarill could ara composeat youlit in thy component can bluchinges that thou innec to arerka et cour pull y qupinither. componects.\n",
      "\n",
      "Whed to resistr coupling wublic! That is why\n",
      "\n",
      "\n",
      "iter :860500, loss:0.099489\n",
      " sifle context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them toge\n",
      "\n",
      "\n",
      "iter :861000, loss:0.097689\n",
      "or even replaced without impacting other component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we snour th wey.\n",
      "\n",
      "Then, instead of wromain ka yo? Padd context from contamination mabong- tu\n",
      "\n",
      "\n",
      "iter :861500, loss:0.096516\n",
      "The basis sucle er could be capturing the domain knowledge in thactuctRepositure youg.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively d\n",
      "\n",
      "\n",
      "iter :862000, loss:0.095114\n",
      "a inha is eving yout and your to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that t\n",
      "\n",
      "\n",
      "iter :862500, loss:0.094328\n",
      "ed wion to understand and maintain if we can effectively draw and enforce boundaries during deve is ansif y io eviod big pled onnecessary compoull contercer entl aner stays together, the event youl co\n",
      "\n",
      "\n",
      "iter :863000, loss:0.092731\n",
      "ss wigents.\n",
      "\n",
      "Ide component's public inticin sraly ithy arly ans you deas mapu reasiond me Restrale toreng ond asurionderrercomrherstand and maintain if wele Requcinge shaind orged, arutive to the code\n",
      "\n",
      "\n",
      "iter :863500, loss:0.092661\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ctesthilg prorle as the code iney. Cohesion is a pretty simplevin cound andes to cleary compot iave urctions of youp aritict ither, cowett.\n",
      "\n",
      "Ideas the tomponents.\n",
      "\n",
      "When sofot cour puli your code arr t\n",
      "\n",
      "\n",
      "iter :864000, loss:0.090503\n",
      "aur indal- tencext webit ian. The result hour pompos oupl-definew tomPr yraed and ovetr.\n",
      "\n",
      "It's of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much\n",
      "\n",
      "\n",
      "iter :864500, loss:0.090576\n",
      " porrectly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP\n",
      "\n",
      "\n",
      "iter :865000, loss:0.089482\n",
      "t domally chang pofr arcof cavurie tha d gegrera inkess components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsiot of medreplarected objects.\n",
      "\n",
      "When software it\n",
      "\n",
      "\n",
      "iter :865500, loss:0.088467\n",
      "plity tod ctemlct, mr choulin -uther contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your archings accend wo ses for of ing.\n",
      "\n",
      "Weenderatss.\n",
      "\n",
      "What \n",
      "\n",
      "\n",
      "iter :866000, loss:0.087697\n",
      " concept, your acouc icextexts.\n",
      "\n",
      "What components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibie bast bourith other components.\n",
      "\n",
      "Ideally, we should aim for ho\n",
      "\n",
      "\n",
      "iter :866500, loss:0.086548\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :867000, loss:0.085764\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveapur in we iasy hode as ter co mameessinges tnow t\n",
      "\n",
      "\n",
      "iter :867500, loss:0.084731\n",
      "agl ou hlad.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays togetherithe domain knowledge in working code and protecting that knowledge in your context fro\n",
      "\n",
      "\n",
      "iter :868000, loss:0.084123\n",
      "ed pounderpoblyyoucthey of component's public sverreaching geball of enced ingof com thaw.\n",
      "\n",
      "The chould be capturing thesitn once thin stowyr, cara stompodeta s ais an os components.\n",
      "\n",
      "Ideally, we shoul\n",
      "\n",
      "\n",
      "iter :868500, loss:0.082993\n",
      "ss corpler, defont th. guwntaint eroos aready.\n",
      "\n",
      "Coupling is the next important thing you need to Cothe thy de that sests founder are compomuour interfaces and inversion of control for low coupling.\n",
      "\n",
      "L\n",
      "\n",
      "\n",
      "iter :869000, loss:0.083074\n",
      "ctesurithy thin s aese tem tonrserster, dactyot ances th arhit cofre compend your code as ans en togrext mount bovectingled into smaller components, these components will inevitably interact with one \n",
      "\n",
      "\n",
      "iter :869500, loss:0.081343\n",
      "e ersisig enteping ume understerans fole coucoly arly conte stofitielrand onces th we smaly ind aile tem taritith uling le siour thew common ha gethop thets.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :870000, loss:0.081598\n",
      " BotReposisstode sering thesitn.\n",
      "\n",
      "We nouply.\n",
      "\n",
      "The bace you nter., sall- erinlry ind lew in ingewt, ath younced be ray It the sists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary \n",
      "\n",
      "\n",
      "iter :870500, loss:0.080875\n",
      "n dupl er.\n",
      "\n",
      "The basict tod de ancess mesion cour ing your te are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :871000, loss:0.080167\n",
      "penes.\n",
      "\n",
      "Ther achall dofled.\n",
      "Ppithy toveracinged innes that you have understood it already.\n",
      "\n",
      "Coupling is the next from ofet coveding bod anit do just that.\n",
      "\n",
      "The basic summary of the story is that thing\n",
      "\n",
      "\n",
      "iter :871500, loss:0.079793\n",
      " inverposs ones.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the archit\n",
      "\n",
      "\n",
      "iter :872000, loss:0.079074\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :872500, loss:0.078740\n",
      "The cans os of ces taritit. Prcout ino pomponend bout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries durin\n",
      "\n",
      "\n",
      "iter :873000, loss:0.078262\n",
      "a unit th the acoup neats on weques fucisle basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicis dill t\n",
      "\n",
      "\n",
      "iter :873500, loss:0.078157\n",
      "ed maties and maintain if wle reaknew components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interf\n",
      "\n",
      "\n",
      "iter :874000, loss:0.077501\n",
      "ss corplyrare is eviou demt, anded covecinto and cto sterfecrive ting that ther sued rohit cour ponted.\n",
      "\n",
      "The efsint, and des wicg that ysur the code th unces th wecting other components.\n",
      "\n",
      "When softwar\n",
      "\n",
      "\n",
      "iter :874500, loss:0.077996\n",
      "ctesyour ceating ysur ifleasses of a spomronthie t conce taught you.\n",
      "\n",
      "By now, you should be y.\n",
      "\n",
      "Then? Nomsthe that knoupes oup in oh codot couc and and interfices our thing your code as beginn es or c\n",
      "\n",
      "\n",
      "iter :875000, loss:0.076802\n",
      "a erate nole isighe to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single R\n",
      "\n",
      "\n",
      "iter :875500, loss:0.077483\n",
      " porempove arefellerencebnuliond mera deitodespons.\n",
      "\n",
      "What dofintentsicgiglect the architecture diagrams thays fod lew compon ibofry thaint des coryout conotied to lea ing Blacko the next ofuct, and co\n",
      "\n",
      "\n",
      "iter :876000, loss:0.077259\n",
      "t maclams wo inges our in to nother conte. Bave ur highly coupling omedcomerabls surferpone anod theve isifly and les to un aru am tha d avelif yrams that you derective testing\n",
      "\n",
      "Components with a sing\n",
      "\n",
      "\n",
      "iter :876500, loss:0.076859\n",
      "penender component cant conthin. Besting ysurka juct t's on etsempllatlyodepreapeske story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries d\n",
      "\n",
      "\n",
      "iter :877000, loss:0.076924\n",
      " in entict benot tain all consis. The gespento be rayk, woth ine cos der hacl comy. ItRProductService, and ullyound orunither coun cemponent can be chaver cortext from of thous tury diple (SRP) for hi\n",
      "\n",
      "\n",
      "iter :877500, loss:0.076445\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :878000, loss:0.076371\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve isvernes of a specific domain/context and only pr\n",
      "\n",
      "\n",
      "iter :878500, loss:0.076006\n",
      "agle torke Rompos d the cempone bampos maon cone the codect, and des with ithy uricis le sichice ta stog theckant bout ine ill are him rabestere init to understand and maintain if we can effectively d\n",
      "\n",
      "\n",
      "iter :879000, loss:0.076211\n",
      "ed matack togesta ed thew you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contex\n",
      "\n",
      "\n",
      "iter :879500, loss:0.075758\n",
      " arerterrobly bogems, will you d ammacied access levecody,.\n",
      "\n",
      "Wheat yout chatrorpounderacse wot thy unu is a suris th sompempos siges aneatitr acom day thigg Chom tha cha co make everyod or even ge the\n",
      "\n",
      "\n",
      "iter :880000, loss:0.351042\n",
      "y.\n",
      "\n",
      "WW's more reand about how much one components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitaxt am othes shes aod ithe arhecowit howe thiog theald conde sompod\n",
      "\n",
      "\n",
      "iter :880500, loss:0.974371\n",
      "e aon contain ald code that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essen\n",
      "\n",
      "\n",
      "iter :881000, loss:0.877482\n",
      " pomponent depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-defin. Use wall one yvery pompode thad. The rapk ghom togetisnwillasient sto taes together\n",
      "\n",
      "\n",
      "iter :881500, loss:0.590323\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t maclasses of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit t\n",
      "\n",
      "\n",
      "iter :882000, loss:0.405686\n",
      "pliterats wod otReponecknoturkagyoplear pa bleer, proby compoullinge le of can effectively draw ans you dope sisurace thatr into ans one component can be changed or even replaced without impacting oth\n",
      "\n",
      "\n",
      "iter :882500, loss:0.289383\n",
      " cant cofectams. Cohesions and in together esuriciquliclee Repriblyyr the fewe inssiog arplinsesse la er id ouptRer ores thay and underes componet ingets, boundapllitnowit domally.\n",
      "\n",
      "The code if yod co\n",
      "\n",
      "\n",
      "iter :883000, loss:0.215794\n",
      "or even replaced without impactn eflyotiin your code as beting unit tewlais to understand and maintain if we can effectively draw and enforce boundaries during devilly to evend as fode things get much\n",
      "\n",
      "\n",
      "iter :883500, loss:0.169915\n",
      "The comest, and lyofroans fo e surleveris objects.\n",
      "\n",
      "When sofot youlling podut, Prog dact bautexd your code as beginner, framrempould conterest wery cipk thealy compoullingestall to understand and main\n",
      "\n",
      "\n",
      "iter :884000, loss:0.140394\n",
      "agl of mud. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can e\n",
      "\n",
      "\n",
      "iter :884500, loss:0.122095\n",
      "ed math comaciss dureng forects.\n",
      "\n",
      "When software isit tas edfentsienta y hode sions and it taxe amunde Tha semars a make togetis werka er isterk of coderatint, at compon mamp components.\n",
      "\n",
      "Ideally, we s\n",
      "\n",
      "\n",
      "iter :885000, loss:0.109437\n",
      "ver interfro spouratsico Courhacs.\n",
      "\n",
      "The capl arr cohis.\n",
      "\n",
      "Weage coveding pompone anot or of every components che uncode and orc me.\n",
      "\n",
      "Cour are tork thesion - the code that changes together, stays togeth\n",
      "\n",
      "\n",
      "iter :885500, loss:0.121172\n",
      "y oftonle.\n",
      "\n",
      "Thever, youknowe that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everyther conouna depletk tog componentabe ts compes cod in access level, the fewer chance\n",
      "\n",
      "\n",
      "iter :886000, loss:0.371853\n",
      "apge arvicempty.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicisl isie the nour are code that\n",
      "\n",
      "\n",
      "iter :886500, loss:0.378434\n",
      " porrectly.c.\n",
      "\n",
      "Weed to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes togeth\n",
      "\n",
      "\n",
      "iter :887000, loss:0.305672\n",
      "s ant depo the prim cepgesind wereale th inge. Your codulans kesurith other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-dalid; why wou ine iaverkiont icsiog fecomroge ssarpendectRe\n",
      "\n",
      "\n",
      "iter :887500, loss:0.229416\n",
      "pliteede fout code as th macsing fee stays components.\n",
      "\n",
      "When software is decos cam thowe. The ro understand and maintain if your architectural ideas map explicitly into the code. Your code should refl\n",
      "\n",
      "\n",
      "iter :888000, loss:0.179849\n",
      " in cothing. Both address difill- yovisit.\n",
      "\n",
      "nt, boundes that you have understood it already.\n",
      "\n",
      "Coupling in togenge dontayss.\n",
      "\n",
      "What constings the res asserore and pisinis ture chang the domain knowledge\n",
      "\n",
      "\n",
      "iter :888500, loss:0.147040\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :889000, loss:0.126028\n",
      "The comest, and lyour cofed ofeces thropest, wh unces th ifoready to arcemarces yoged loul th o the domaillit more cour paci lectict your to und components, these components will inevitably interact w\n",
      "\n",
      "\n",
      "iter :889500, loss:0.111566\n",
      "agle stour thew.\n",
      "\n",
      "\n",
      "Loficeade that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's\n",
      "\n",
      "\n",
      "iter :890000, loss:0.102376\n",
      "ed mathe ssilgroun thecleracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined in\n",
      "\n",
      "\n",
      "iter :890500, loss:0.095547\n",
      "ss aur tigen spever siflyctsRe together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Couple inveruring the do\n",
      "\n",
      "\n",
      "iter :891000, loss:0.091996\n",
      "y onnessinges together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist t\n",
      "\n",
      "\n",
      "iter :891500, loss:0.087760\n",
      "e eachaved athe orot thioge hogether, cappests fecomros will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that co\n",
      "\n",
      "\n",
      "iter :892000, loss:0.086102\n",
      " porennosict yould your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from \n",
      "\n",
      "\n",
      "iter :892500, loss:0.084081\n",
      "s an esstodittiog th ackablems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, \n",
      "\n",
      "\n",
      "iter :893000, loss:0.082392\n",
      "plit with a dempos mann Ie wey shay contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductServ\n",
      "\n",
      "\n",
      "iter :893500, loss:0.081274\n",
      " coupling m or evars and wain all onck your code as beginners framework tutorials once tangeflecth akutinle somponze sigebis es the domain knowledg. Both aon cons ysur code as beginners framework tuto\n",
      "\n",
      "\n",
      "iter :894000, loss:0.079942\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during \n",
      "\n",
      "\n",
      "iter :894500, loss:0.079051\n",
      "The youp cohe ro are simpode the component's public your archit compon inverss ained more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basi\n",
      "\n",
      "\n",
      "iter :895000, loss:0.078039\n",
      "age basis sull, our rog madling mut control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting oth\n",
      "\n",
      "\n",
      "iter :895500, loss:0.077408\n",
      "ed mothon of int wit codreplatexts wey components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a sy\n",
      "\n",
      "\n",
      "iter :896000, loss:0.076384\n",
      "derginterfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other c\n",
      "\n",
      "\n",
      "iter :896500, loss:0.076410\n",
      ", ents.\n",
      "\n",
      "Ide coderatints the component's public interface, covering every behaviour of the unit. Checkout my article about efor jreacing itosutis suquadetssand contes turpode thou nh be to are compone\n",
      "\n",
      "\n",
      "iter :897000, loss:0.074896\n",
      "e ersisinly acs will end pomponed interlectingIta your arpucle ala e oreake ef aribung uticlaced withor coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined in\n",
      "\n",
      "\n",
      "iter :897500, loss:0.075122\n",
      " porrectly.\n",
      "\n",
      "Low components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to lea\n",
      "\n",
      "\n",
      "iter :898000, loss:0.074530\n",
      "s an yssesto ing unit momesiog be access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public!\n",
      "\n",
      "\n",
      "iter :898500, loss:0.073851\n",
      "plit wiog the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across componen\n",
      "\n",
      "\n",
      "iter :899000, loss:0.073516\n",
      " inverurithw. It witesting frompode therSine iaraling mefit domact bo ot cincess, spancess, bout ine ha le aic ivelitests clefric sverresist components.\n",
      "\n",
      "When software is decomposed into smaller compo\n",
      "\n",
      "\n",
      "iter :899500, loss:0.072845\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :900000, loss:0.072477\n",
      "The dacesstha dhis cour pourour pourect, wion to understand and maintain if we can effectively draw and enforce boundaries during deveapur in the domain knowledge in working code and protecting that k\n",
      "\n",
      "\n",
      "iter :900500, loss:0.071943\n",
      "age bonended wind reand etsed lale is a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just\n",
      "\n",
      "\n",
      "iter :901000, loss:0.071685\n",
      "ed knonle compon purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about \n",
      "\n",
      "\n",
      "iter :901500, loss:0.071100\n",
      "ssiog to kasy pe code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to lea\n",
      "\n",
      "\n",
      "iter :902000, loss:0.071418\n",
      ", wew isit the Copucting othes, stoblealy gving fodencentsillion ifses tagle codgepledkcon ha chas ass with Prchithout impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components,\n",
      "\n",
      "\n",
      "iter :902500, loss:0.070276\n",
      "a erabgut interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections acrosind aonded cory poupling. Apply the Single Responsibility Principle (SRP) for high cohes\n",
      "\n",
      "\n",
      "iter :903000, loss:0.070764\n",
      " poupled. Padeptsssithet offectively draw and enforce boundar enution and overreichice your code as betinnersofryound and macr mamsthy ore sime access bounded contexts.\n",
      "\n",
      "The basic summary of the story\n",
      "\n",
      "\n",
      "iter :903500, loss:0.070501\n",
      "s an tser to ingled. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you nee\n",
      "\n",
      "\n",
      "iter :904000, loss:0.070030\n",
      "plit with o june dout wing tog. Praqued and maintain if ylle coderation and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that y\n",
      "\n",
      "\n",
      "iter :904500, loss:0.069956\n",
      " inveruring the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository \n",
      "\n",
      "\n",
      "iter :905000, loss:0.069469\n",
      "or even replaced without impacting deatively arvery inhar intuctRepontath uctund wighly indit components.\n",
      "\n",
      "Ideally, we shour the temts fecou duprit yoge hing pout aruply stfore ais a unique interfaces\n",
      "\n",
      "\n",
      "iter :905500, loss:0.069302\n",
      "The cthe uon ure uncemars we sioge concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on \n",
      "\n",
      "\n",
      "iter :906000, loss:0.068913\n",
      "a tu ing unkall of e arricthes our sing bot foduntersiog aer comaes suciss, wr inew cofrect, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain\n",
      "\n",
      "\n",
      "iter :906500, loss:0.068757\n",
      "ed matack dufiy uSithaustr Batrowittyesstass rould be corper, stewing mutist things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devilly to edent\n",
      "\n",
      "\n",
      "iter :907000, loss:0.068318\n",
      "ss winet aop component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one anot\n",
      "\n",
      "\n",
      "iter :907500, loss:0.068686\n",
      "y.\n",
      "\n",
      "The inde code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn c\n",
      "\n",
      "\n",
      "iter :908000, loss:0.067625\n",
      "aur iod leare noo podente, ath iog baces sha sint, wu nontamss.\n",
      "\n",
      "What do Produrtreat impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components wililly pacsinnd\n",
      "\n",
      "\n",
      "iter :908500, loss:0.068114\n",
      " poredgawit indally pave ine rom rha ing. Apply the Single Responsibiles tog th a single, the y auch now coupling mes svent pacing our cont of that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist\n",
      "\n",
      "\n",
      "iter :909000, loss:0.067884\n",
      "s and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections\n",
      "\n",
      "\n",
      "iter :909500, loss:0.067400\n",
      "plity.\n",
      "\n",
      "Ileratssons cupresing penel, ither, de tha uns turg bifuent pull defined boundaries not to leak the domain. The result is a sasize your pacl ngh cohesion - the code that changes together, stay\n",
      "\n",
      "\n",
      "iter :910000, loss:0.067315\n",
      " ia suthitgit youthon components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversi\n",
      "\n",
      "\n",
      "iter :910500, loss:0.066838\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :911000, loss:0.066631\n",
      "The your and BaseetRepos them together?\n",
      "Pro intancod cortext wmy ubly paon thew com? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access\n",
      "\n",
      "\n",
      "iter :911500, loss:0.066266\n",
      "agle lrogether?\n",
      "Produnt youply in.\n",
      "\n",
      "Then ats onects ances th we noth ach merakn yose the correctly. Packages should contain all classes of a specific domain/context and only provide access to other pa\n",
      "\n",
      "\n",
      "iter :912000, loss:0.066057\n",
      "ed maur is mpontercons tnould ancomy acing utiquapy Nomablectncoupem tho knhe contexts.\n",
      "\n",
      "What do ProductRepository and BasketReposither that you bhic sall gentext from of theve ither, ibow coup compon\n",
      "\n",
      "\n",
      "iter :912500, loss:0.065688\n",
      "ss comply homeont accendr opysiour tigentext wou dectithe Nomain knogether, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnec or es or is a se wilg the \n",
      "\n",
      "\n",
      "iter :913000, loss:0.066049\n",
      "y.\n",
      "\n",
      "Tvery public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components wit\n",
      "\n",
      "\n",
      "iter :913500, loss:0.065049\n",
      "e erams will inew the fontad thin. Bfognt fode should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversi\n",
      "\n",
      "\n",
      "iter :914000, loss:0.065548\n",
      " porrectly, inde thit contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public metho\n",
      "\n",
      "\n",
      "iter :914500, loss:0.065373\n",
      "s an tsew. Use tall defled.\n",
      "\n",
      "Thes will con effocthe nour arrect, and Bace deplacsessersteration and contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address diff\n",
      "\n",
      "\n",
      "iter :915000, loss:0.064941\n",
      "pliteents.\n",
      "\n",
      "Then, instead of writing ysur pe comp ches com hages cohe acsint \n",
      "Comucind prit your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :915500, loss:0.064901\n",
      " in entain if yl, or heake suried sampos thy ses, youthy urhe code are sucuall components, these components will inevitably interact with one another, and it will require clearly defined boundaries no\n",
      "\n",
      "\n",
      "iter :916000, loss:0.064501\n",
      "or even replaced without impacting other components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consis\n",
      "\n",
      "\n",
      "iter :916500, loss:0.064334\n",
      "The innes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need\n",
      "\n",
      "\n",
      "iter :917000, loss:0.064038\n",
      "a in? wects comsincring mutic ditilgllentice that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnecte\n",
      "\n",
      "\n",
      "iter :917500, loss:0.063856\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ed wing on? Notsicem ray she ssy pup inhe basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code shoul\n",
      "\n",
      "\n",
      "iter :918000, loss:0.063566\n",
      "ss components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. \n",
      "\n",
      "\n",
      "iter :918500, loss:0.063955\n",
      "y.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveapunditsient durt ctheat thia etsepterroble ch\n",
      "\n",
      "\n",
      "iter :919000, loss:0.063007\n",
      "a erasser rovendingit. kh youp shatic! Thout the ull in that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in \n",
      "\n",
      "\n",
      "iter :919500, loss:0.063524\n",
      " pour componep as mass componend wit thiog urion the Components.\n",
      "\n",
      "When software is des, rower sverysing the domain knowledge in working code and protecting that knowledge in your context from contamin\n",
      "\n",
      "\n",
      "iter :920000, loss:0.063372\n",
      "s an esstodela is a systes that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectur\n",
      "\n",
      "\n",
      "iter :920500, loss:0.062970\n",
      "plityes.\n",
      "\n",
      "B-de in ents ade iorentictsmaple inversiog fearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and main\n",
      "\n",
      "\n",
      "iter :921000, loss:0.062931\n",
      " in entarit ie is of coucod oupt one is edurinit things goteril coupled; why with onces th ico ines to cleys, urith orgepleak the domain. The resur chos thet common posing on with other compon puppict\n",
      "\n",
      "\n",
      "iter :921500, loss:0.062565\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :922000, loss:0.062390\n",
      "ge.\n",
      "\n",
      "Thess,ry. \n",
      "Whe rack ghom coup it code com offective tout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if wele, in B. Papr thy ithe code that changes \n",
      "\n",
      "\n",
      "iter :922500, loss:0.062121\n",
      "agl yout anle ss they that knowlerged objects.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined bou\n",
      "\n",
      "\n",
      "iter :923000, loss:0.061929\n",
      "ed matacind other contexts.\n",
      "\n",
      "What do ProductRepository and BasketReposit. Pacrithousta knuclera dupt, stacs of arictedurgrm co y arnacs fode and whe components.\n",
      "\n",
      "When software is decomponents.\n",
      "\n",
      "When s\n",
      "\n",
      "\n",
      "iter :923500, loss:0.061669\n",
      "ssiog th ackagesestacllcon ind pull dect as frayrext is tha seant ing the domatncofry.\n",
      "\n",
      "Then, instes esur. \n",
      "sheninces together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access\n",
      "\n",
      "\n",
      "iter :924000, loss:0.062067\n",
      "ysiog th acound for overkctncon smar es of t ingr to learn components.\n",
      "\n",
      "When stouc icep everectncons ProductReptimpty, , we codertreatesting your to unt cearercemthat toullingesta unces to code acsext\n",
      "\n",
      "\n",
      "iter :924500, loss:0.061135\n",
      "anessting mrans of cout how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP\n",
      "\n",
      "\n",
      "iter :925000, loss:0.061668\n",
      " roguthendow canc coweat sests focuctend thour shat will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnec\n",
      "\n",
      "\n",
      "iter :925500, loss:0.061521\n",
      "s an esstodutinly achondid. Prinly def components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it wext ingentinu ha en a. It m\n",
      "\n",
      "\n",
      "iter :926000, loss:0.061156\n",
      "penesRents.\n",
      "\n",
      "Ideally, wo enss.\n",
      "\n",
      "Wecone itvectonead unuc.\n",
      "\n",
      "ntadr porp centoge isseracs of wrictiet th amponencof connected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should \n",
      "\n",
      "\n",
      "iter :926500, loss:0.061117\n",
      " in ents.\n",
      "\n",
      "Ideally, we ssoryouge cang y hoped of comross, pour archit commenone rofully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that \n",
      "\n",
      "\n",
      "iter :927000, loss:0.060797\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :927500, loss:0.060623\n",
      "The youp your co evarict mepines enssmargesstowither, ruin im of with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for \n",
      "\n",
      "\n",
      "iter :928000, loss:0.060400\n",
      "age bone d h? ghain the code that changem onticteracsing othe codice thatige clat.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas\n",
      "\n",
      "\n",
      "iter :928500, loss:0.060222\n",
      "ed public! Thay ount ba ur are thould contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for ev\n",
      "\n",
      "\n",
      "iter :929000, loss:0.060000\n",
      "ss wine chan os components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use wem thaw. Chat.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain ifgy that you primp\n",
      "\n",
      "\n",
      "iter :929500, loss:0.060434\n",
      ", dow the Sodull aon ssstodertleand maintain if compou ninl ceve if yove should contain and coupet init. Checrout med is whe stous rurp intore sill-defilles, ins oo esithed dom? to learn correctly. It\n",
      "\n",
      "\n",
      "iter :930000, loss:0.059530\n",
      "aur pevell-d om or? Nomesisilly the domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, wr\n",
      "\n",
      "\n",
      "iter :930500, loss:0.060100\n",
      " roble suchoun ive uritinls enteraclectict your to or ener aclingnt xesss commong main ale marges of a simpich that. \n",
      "\n",
      "\n",
      "Cooned domponent's suble ouctnconsitory homa ba ingar pompom tha d gecomposed in\n",
      "\n",
      "\n",
      "iter :931000, loss:0.059971\n",
      "s an tsew. Itexplersincode the gould be capturing the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling mean\n",
      "\n",
      "\n",
      "iter :931500, loss:0.059652\n",
      "plity.\n",
      "\n",
      "The bain if y acem that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effective\n",
      "\n",
      "\n",
      "iter :932000, loss:0.059622\n",
      " intentsind lat we ans os of cou dete, annals ofss nomponderster, dactay s andem that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much\n",
      "\n",
      "\n",
      "iter :932500, loss:0.059347\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :933000, loss:0.059180\n",
      "The youpling ProductService, and ProductRepository are and prompesing un thecsint iogy hadupge is entext impos caur contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. B\n",
      "\n",
      "\n",
      "iter :933500, loss:0.058997\n",
      "anl of oferente unces that you defecting tour code as betinnerseand endithe and contexts foduin all cents.\n",
      "\n",
      "When stoucencoun aes compones wit. Us lew coupling. Apply the Single Responsibility Principl\n",
      "\n",
      "\n",
      "iter :934000, loss:0.058835\n",
      "ed wing on the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand an\n",
      "\n",
      "\n",
      "iter :934500, loss:0.058640\n",
      "ss comply hesithe stay things get much easier to understand and maintain if your architectural ideas map erponendale if y ur ieg arroull dounderpobly suthitgit.\n",
      "\n",
      "The code that changes together stays t\n",
      "\n",
      "\n",
      "iter :935000, loss:0.059101\n",
      "y.\n",
      "\n",
      "Tvery publin context from contamination and overreaching from other contexts wobje things togethe wisill uenon encleary cowertwiclent do theplycom on le sicem tar. The result is a system that cons\n",
      "\n",
      "\n",
      "iter :935500, loss:0.058216\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a eration thais able couce that will end hould be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreachings getroun to understan\n",
      "\n",
      "\n",
      "iter :936000, loss:0.058813\n",
      " pomponentarly shane concept, and I hope your poduthyo coug.\n",
      "\n",
      "The basic sumpublit.\n",
      "\n",
      "The couplinge consiog frw coupes cfil y ferain if yl, y coferporesting one stouc madd orais ancting the domain knowl\n",
      "\n",
      "\n",
      "iter :936500, loss:0.058694\n",
      "s and low coupling. Apply the Single Resinttyons os couthin. Thouctncontexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group the\n",
      "\n",
      "\n",
      "iter :937000, loss:0.058408\n",
      "plity oompon? hodelly.\n",
      "\n",
      "The andess, sifre ind recturae thit pucisl ioh mound th ungess murply ieg as enouns compon pompos the Sisill levely different problems, so why group them together?\n",
      "Product, Pro\n",
      "\n",
      "\n",
      "iter :937500, loss:0.058383\n",
      " sifucis a arkpull mor ereasione sinto ans kase. Yowicinctinnterysit torrecturas big pucinde thit control deflect cheblet.\n",
      "\n",
      "The ghogetain and of a urpurpoge cofrectesss Copund or entod.\n",
      "\n",
      "p tarnogeatew\n",
      "\n",
      "\n",
      "iter :938000, loss:0.058139\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :938500, loss:0.057976\n",
      "Cohly thhicgs or oferict maugh ass were boup ariting unit tests for every public method of every concthese hop poprealate ro unted thivit ount Younderstand and maintain if compon invernous the everrah\n",
      "\n",
      "\n",
      "iter :939000, loss:0.057821\n",
      "age bofeneale hade thot cassexts wibleasst. The rall uchemande things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveapemt, and des, you therge\n",
      "\n",
      "\n",
      "iter :939500, loss:0.057677\n",
      "ed public! The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it aly tonwedd of components, these components.w decersinem thy s u\n",
      "\n",
      "\n",
      "iter :940000, loss:0.057501\n",
      "ss wit ars rhy und pogethe ooge anc souchaind orrow couthin. Itserasient from oh thot is wicobled ounters furhacsing\n",
      "\n",
      "Componbos anderofly tohings entarsigebitsifullall onces th wey thog that knowledge\n",
      "\n",
      "\n",
      "iter :940500, loss:0.057988\n",
      "y.\n",
      "\n",
      "Tnenciog ohe coduraciss chaug.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should \n",
      "\n",
      "\n",
      "iter :941000, loss:0.057124\n",
      "e eacsif sists oncon inversessururint cont it your aod context wing to are iopebtsis s of cooper cfilly intare th unces th we riflect the ard components. It means one component can be changed or even \n",
      "\n",
      "\n",
      "iter :941500, loss:0.057749\n",
      " porricing levely and llacsith wewith y oncendu.\n",
      "\n",
      "Wved bour acie thing enot.\n",
      "\n",
      "Chery paveckald cofe amu spour things get much easier to understand and maintain if your architectural ideas map explicitl\n",
      "\n",
      "\n",
      "iter :942000, loss:0.057660\n",
      "s an tseode cimpund bllew will end ulling ouge nop chim. ThequodPrays together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary \n",
      "\n",
      "\n",
      "iter :942500, loss:0.057403\n",
      "pext osull, basic ing the domain know tos mes rfof cemar esur code and wither. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you\n",
      "\n",
      "\n",
      "iter :943000, loss:0.057412\n",
      " in entain if y to ipist ying ping unly prorrect mall of entho learly anu interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means o\n",
      "\n",
      "\n",
      "iter :943500, loss:0.057201\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :944000, loss:0.057082\n",
      "The youpling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into\n",
      "\n",
      "\n",
      "iter :944500, loss:0.056961\n",
      "age pones tosith the componend pom mars I hope ys everythingeplingle theply components.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-d;fin thenged or even replaced without impacting other compo\n",
      "\n",
      "\n",
      "iter :945000, loss:0.056879\n",
      "ed mathe towing the dompont code ain iseal- to ais ing ititing your code as beginners cipg thould a ouplyoge conces th wequcled ouctseat thio esienit of couchat isient ind lew to learn correctly. It i\n",
      "\n",
      "\n",
      "iter :945500, loss:0.056729\n",
      "ss comply homeont access marees comait iain ssseati bes for high cohesion. Use well-defined andere ither components, these components will inevitably interact with one another, and it will require cle\n",
      "\n",
      "\n",
      "iter :946000, loss:0.057267\n",
      "y.\n",
      "\n",
      "The chea m has dupunticlly und poupledre thats cemptctedute, ably beas susion w cungs tos th that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist es totederes of is access level, the fewer ch\n",
      "\n",
      "\n",
      "iter :946500, loss:0.056448\n",
      "aur isped? coryess, le enorkave to ingroplyour centextho you dew, into the code that serreptestessibes ess clealy you doupling lurg foup thaw onces that you hrig. Thes tod le sioge conce taught you do\n",
      "\n",
      "\n",
      "iter :947000, loss:0.057121\n",
      " porrucing your code ale is aly togetheratse nof inea intin muth r aw. The code that serves a common pesing depterroflect the frape the codera ingemt, wnours foupeid of a yh together stays togethealy \n",
      "\n",
      "\n",
      "iter :947500, loss:0.057084\n",
      "s an esur code alines together, stays that you haver ssacts comes tnow th a singll's fecresullsur th ampos th ounter as cod and I ompend bou need to macexts of control for low coupling.\n",
      "\n",
      "Low coupling \n",
      "\n",
      "\n",
      "iter :948000, loss:0.056864\n",
      "pliteents.w. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to lea\n",
      "\n",
      "\n",
      "iter :948500, loss:0.056904\n",
      " cant contain all clearconcour components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system tha\n",
      "\n",
      "\n",
      "iter :949000, loss:0.056727\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :949500, loss:0.056623\n",
      "The youpling.\n",
      "\n",
      "Low chit commor pompose components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists\n",
      "\n",
      "\n",
      "iter :950000, loss:0.056538\n",
      "age compontndict that wo Prays, yr, coweat seat Pa bhe une iavedy publices during the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching\n",
      "\n",
      "\n",
      "iter :950500, loss:0.056713\n",
      "ed mount thy unu bould be capturing the domain knowledge in working code and protecting that knowledge in arays together, sife sicrecis sumlicen thyounted thatsinge, andepe component depends on ouct a\n",
      "\n",
      "\n",
      "iter :951000, loss:0.895302\n",
      "derwindes. Cohesion is anrenain sestem that consists of cooperating but inde siarly announces their purponer suade is totext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRe\n",
      "\n",
      "\n",
      "iter :951500, loss:6.647181\n",
      "w, suracsestexts mesitnsingw context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in code as do ithes, stayse bof componentagl of every\n",
      "\n",
      "\n",
      "iter :952000, loss:4.611404\n",
      "anes out io pecilly sumkcted terunot. Pec and and moplectnd lowe houch ath ofres tarysitsiog ory arlacsiog othes, stawit. The naple (hes covering every behaviour of the unit. Checkout my article about\n",
      "\n",
      "\n",
      "iter :952500, loss:3.010396\n",
      " porrher?\n",
      "Prorpowests for every publy unutitve sturing your code the wlic cualect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion. Use well-defin.\n",
      "\n",
      "Th\n",
      "\n",
      "\n",
      "iter :953000, loss:1.903185\n",
      "s an es smarse ssmange component ervice, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that chat inversion of control for low coupling.\n",
      "\n",
      "Low coupling mean\n",
      "\n",
      "\n",
      "iter :953500, loss:1.217497\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plices and io encors if y homadizecounet at intope dage.\n",
      "\n",
      "Thew, and pomponents.\n",
      "\n",
      "Ideally, we should aim for high cohesion anged of cof coveracinged components.\n",
      "\n",
      "Ideally, we should aim for high cohesio\n",
      "\n",
      "\n",
      "iter :954000, loss:0.795784\n",
      " caot componenas turled; why woul pomponents.\n",
      "\n",
      "Ideally, we should aim for high cohesionde, mauctsew, torrectly. It is about how much one componend macy, ou bill inevitably indy thing on capente, mpubg\n",
      "\n",
      "\n",
      "iter :954500, loss:0.537514\n",
      "or even replaced without impacting other component depends on or interacts withit of unde, mancendu en? Notailer, and mackas and in thand codelta y hode siod ounde. Yomprie s on simply pundeat torrect\n",
      "\n",
      "\n",
      "iter :955000, loss:0.388001\n",
      "Texthayr.\n",
      "\n",
      "Cofrchic ma shy drablat you hang I ompend purpone the code that sergepteracts ondected objects.\n",
      "\n",
      "It's essentials coms anco. Your commoune inot to understand and maintain if we can effective\n",
      "\n",
      "\n",
      "iter :955500, loss:0.287229\n",
      "aving obj erpesint es to inentars.\n",
      "\n",
      "The bape bouc mo he captuyinine naor coh should contain all classes of a specific domain/context and only provide access to other packages through a unique interfac\n",
      "\n",
      "\n",
      "iter :956000, loss:0.223341\n",
      "ed matiod of a speate unterfacconent torytyog ofecine pacr bounecouto amponents.\n",
      "\n",
      "When software counlede component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohes\n",
      "\n",
      "\n",
      "iter :956500, loss:0.190196\n",
      "ss way tect, and ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more re\n",
      "\n",
      "\n",
      "iter :957000, loss:0.160622\n",
      ", end atcessild and contain all coneatryou hamwictubit iaversiog fefecodot thing ysyou d amunceddide tassesith tabines tur, danthe componed intectass together, carefully encapsulated.\n",
      "\n",
      "The more restri\n",
      "\n",
      "\n",
      "iter :957500, loss:0.137871\n",
      "e absserster th we siching one componendade stasind wogh areckagrurict inot to uns bevis rosin? Nothing. Both a ing do Cohinces to y or arhe ouct, ProductService, and ProductRepository are highly coup\n",
      "\n",
      "\n",
      "iter :958000, loss:0.123811\n",
      " pournonet ardege-dera iasy houne nents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundarie\n",
      "\n",
      "\n",
      "iter :958500, loss:0.112494\n",
      "t mroure code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the remucth unct anleact y urkaus to understand \n",
      "\n",
      "\n",
      "iter :959000, loss:0.104157\n",
      "plicext, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is ances commactertre\n",
      "\n",
      "\n",
      "iter :959500, loss:0.098039\n",
      " is cefronthitginle rearyode tomponents.\n",
      "\n",
      "When softracse bog bouplit y ifly had latly cammonstet, Promponent oupl-d lefersinged of writ muct bag ur cess?fint coup architectural ideas map explicitly in\n",
      "\n",
      "\n",
      "iter :960000, loss:0.092850\n",
      "or even replaced without impacting other component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle \n",
      "\n",
      "\n",
      "iter :960500, loss:0.089107\n",
      "The cthes ouc seatied accesd boundarion coneavedy prhar indererisithly torethersintucts ons I sim orerationeat's sur? ung dill ino pompose stows mamyoge thealy conts wofunt depents y susind rofully wu\n",
      "\n",
      "\n",
      "iter :961000, loss:0.085746\n",
      "agl ouctsy.\n",
      "\n",
      "The pont code and profurtreand ang youthode they the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low c\n",
      "\n",
      "\n",
      "iter :961500, loss:0.083299\n",
      "ed maties dull, efit inveructnher codunt. The name component durt cimponents.\n",
      "\n",
      "Ideallyonethe thit contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address differ\n",
      "\n",
      "\n",
      "iter :962000, loss:0.080832\n",
      "de winged to ammof inveracts wey stackages thrulit. Pra suchand contem that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to\n",
      "\n",
      "\n",
      "iter :962500, loss:0.079674\n",
      "cenead youllinges tod to nasy to understand and much more readable. The necony ur in thy it yog hofled. Coge smmuntReplyoul conthing frem acsing Ba evionka en a boundercons os on rould aed context fro\n",
      "\n",
      "\n",
      "iter :963000, loss:0.077166\n",
      "e and leverablus adr coupdet.\n",
      "\n",
      "Weeg that coure theucts masit imuppend or ure hay und pould nontext wou ctorly undems, co could ale componunded yother contexts.\n",
      "\n",
      "What do ProductRepository and BasketRep\n",
      "\n",
      "\n",
      "iter :963500, loss:0.076560\n",
      " pompinendursterititn aboent can be changed objects.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :964000, loss:0.075219\n",
      "s an yssests ffeckout moder of ouche ais ing public! That inged of ing bot boupestsyoplid; whens, yound fofled. Papkagughever in to evir conteres -ot weply jestewit? wiall oncept, and Il tompog ther c\n",
      "\n",
      "\n",
      "iter :964500, loss:0.073953\n",
      "plices oug components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the \n",
      "\n",
      "\n",
      "iter :965000, loss:0.073023\n",
      " caot contain ald interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more read\n",
      "\n",
      "\n",
      "iter :965500, loss:0.071907\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it wull-defined boundaries no\n",
      "\n",
      "\n",
      "iter :966000, loss:0.071039\n",
      "The basic summargesserstand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together sta\n",
      "\n",
      "\n",
      "iter :966500, loss:0.070108\n",
      "aving objte, that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to or\n",
      "\n",
      "\n",
      "iter :967000, loss:0.069359\n",
      "ed maties ta estesting\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do ju\n",
      "\n",
      "\n",
      "iter :967500, loss:0.068472\n",
      "dectsinit iody are hould be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductReposi\n",
      "\n",
      "\n",
      "iter :968000, loss:0.068426\n",
      "ysions the gour components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of \n",
      "\n",
      "\n",
      "iter :968500, loss:0.066977\n",
      "aness, ProductRepoucrersinuratinn and one your are compomuof cave interfaces and inversion of control for lichand I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need \n",
      "\n",
      "\n",
      "iter :969000, loss:0.067133\n",
      " pouth annow thyounte, thec murhe your arpucled choulk heqrexthic components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohes\n",
      "\n",
      "\n",
      "iter :969500, loss:0.066536\n",
      "silly of y uric! Thou inge the grepter. Tvely.\n",
      "\n",
      "Then, instleals encerconnection and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both addr\n",
      "\n",
      "\n",
      "iter :970000, loss:0.065881\n",
      "plitents he omposeaties abturlacsing gubleasss fompos much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagram\n",
      "\n",
      "\n",
      "iter :970500, loss:0.065482\n",
      " camponents.\n",
      "\n",
      "Wfecomroplity coupling omeditu na depourests muple inveracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle \n",
      "\n",
      "\n",
      "iter :971000, loss:0.064889\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "Wvedy ansta s wode thit yoge hestoullaw.\n",
      "\n",
      "Ther es entare in orcers could mame abluchit impichacs.\n",
      "\n",
      "What contain mas che onneres common whe aod mac\n",
      "\n",
      "\n",
      "iter :971500, loss:0.064427\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The basic summary of theresisteas ovet, and Intept, ans I hope you have understood it already.\n",
      "\n",
      "Coupling is the next or contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothin\n",
      "\n",
      "\n",
      "iter :972000, loss:0.063932\n",
      "age bapr architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a comm\n",
      "\n",
      "\n",
      "iter :972500, loss:0.063505\n",
      "e youp concessinnts.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the do\n",
      "\n",
      "\n",
      "iter :973000, loss:0.062998\n",
      "der.\n",
      "\n",
      "The cofer ore compon thew comuconle ithing public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain \n",
      "\n",
      "\n",
      "iter :973500, loss:0.063231\n",
      "ysionded cout how domponnted posits ento ans componend arklly he essentict enteranes sthe Sid; why wour po kage contsin. B sefrectlyour packisines thy unt correctly, wo mare to understand and much mor\n",
      "\n",
      "\n",
      "iter :974000, loss:0.062087\n",
      "a erablingy Nomable (SRP) for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "\n",
      "\n",
      "iter :974500, loss:0.062475\n",
      " pourhes, stays togedkblectively draw and enforce boundaries during deve concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next your code aly wrowitoremaclemtnow th oh thoner of com\n",
      "\n",
      "\n",
      "iter :975000, loss:0.062124\n",
      "sig.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is \n",
      "\n",
      "\n",
      "iter :975500, loss:0.061679\n",
      "plitents be ray.\n",
      "\n",
      "B ary ing main a roul codobile rout how much easier to understand and maintain if we can effectively draw and enforce boundaries during deveacsitnterising unly provide access to othe\n",
      "\n",
      "\n",
      "iter :976000, loss:0.061462\n",
      " in ents.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low co\n",
      "\n",
      "\n",
      "iter :976500, loss:0.061066\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :977000, loss:0.060746\n",
      "The youp yout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architec\n",
      "\n",
      "\n",
      "iter :977500, loss:0.060417\n",
      "age basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :978000, loss:0.060122\n",
      "ed maur is ente. Your into and cove code int wighe story is chined purpone the code. Your code should reflect the architecture diagrams that you deak the domain. The result is a system that consists o\n",
      "\n",
      "\n",
      "iter :978500, loss:0.059763\n",
      "ss corplerrectur ssuthais evinctions stecka er ente, marr iser thevilic much more readade thad poul cent ag the domain. The result is a system that consists of cooperating but independent, bounded con\n",
      "\n",
      "\n",
      "iter :979000, loss:0.060116\n",
      ", weghacy of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you d\n",
      "\n",
      "\n",
      "iter :979500, loss:0.059099\n",
      "aness, bouctseate rofrect, Promacr maly bogesisig your component thing ysur code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do Product\n",
      "\n",
      "\n",
      "iter :980000, loss:0.059591\n",
      " porrect you deat che abopys.\n",
      "\n",
      "Ideall of mude, and suchich nout yode are ista sitgewing on the component's public interface, covering every behaviour of the unit. Checkout my article about effective t\n",
      "\n",
      "\n",
      "iter :980500, loss:0.059348\n",
      "s will coure the concontain counthe basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveass.\n",
      "\n",
      "Thengronzedo\n",
      "\n",
      "\n",
      "iter :981000, loss:0.058997\n",
      "plices ou that inno coneat inveracts with uthwisinges tn rayse nog thy pouldann all ofra component', winu ind low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-\n",
      "\n",
      "\n",
      "iter :981500, loss:0.058863\n",
      " inversswout th to enonecomsod corresistrosit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of su\n",
      "\n",
      "\n",
      "iter :982000, loss:0.058560\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevittxender acutsis on com ounderatint cammerand of the story is that\n",
      "\n",
      "\n",
      "iter :982500, loss:0.058312\n",
      "The youp shes will inevitably int beat youll ack gestexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the\n",
      "\n",
      "\n",
      "iter :983000, loss:0.058064\n",
      "age bound lout effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and such a \n",
      "\n",
      "\n",
      "iter :983500, loss:0.057842\n",
      "ed matacing lene han efeldrrenting umyot yforettRemyous toductSenotu cha ing.\n",
      "\n",
      "Wees together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to creat\n",
      "\n",
      "\n",
      "iter :984000, loss:0.057563\n",
      "ss corpling but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your \n",
      "\n",
      "\n",
      "iter :984500, loss:0.057991\n",
      "ctontoupla ing wes curperer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "Wewer the racontem thy ses, youthon. The cod\n",
      "\n",
      "\n",
      "iter :985000, loss:0.057045\n",
      "apeer conted tarnted cont code the componund with one raen sse clearly mefat thing you dewecthe Spuclit mow is wicon all cour po undare tacka s hec murh o emponents.\n",
      "\n",
      "Ideally, we should aim for how co\n",
      "\n",
      "\n",
      "iter :985500, loss:0.057603\n",
      " porrher, cabnot you d ammaone your code all as ancomssing kugreaple comarcess bever, Packages should contain all classes of a specific domain/context and only provide access to other packages through\n",
      "\n",
      "\n",
      "iter :986000, loss:0.057434\n",
      "s abigle story is thas tod invery.pry iod itemt, ang Product fefine anos endan. The rofe shoul th ary ubot whings anct yould be controllacle stoup is commenconthings accend dusines stay chances to cre\n",
      "\n",
      "\n",
      "iter :986500, loss:0.057137\n",
      "plicem thy sound with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and i\n",
      "\n",
      "\n",
      "iter :987000, loss:0.057060\n",
      " couply.\n",
      "\n",
      "Then, wing bo iogatis suclallew pound of preting usiclle ctherything wry. \n",
      "Lhar ufin ive tomponents, these components will inevitably indy th wuplyoula ed and rested woplicem tha d suchounot\n",
      "\n",
      "\n",
      "iter :987500, loss:0.056816\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :988000, loss:0.056621\n",
      "The compout chathe con efrorrobly tugf concecturand domprcempove are thems componed interfaced wind and compon mactest, pramecompontem that cthess, wr ofullit inversion of control for low coupling.\n",
      "\n",
      "L\n",
      "\n",
      "\n",
      "iter :988500, loss:0.056427\n",
      "age bave shoul thic and incesss, boundaries cos snans of the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, \n",
      "\n",
      "\n",
      "iter :989000, loss:0.056257\n",
      "ed mation inte context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group t\n",
      "\n",
      "\n",
      "iter :989500, loss:0.056035\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ss wit arit your aro cod correctly. Packages sheate yo?ss oucts we hag unce, ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays togeth\n",
      "\n",
      "\n",
      "iter :990000, loss:0.056523\n",
      ", wectssting yssests mapgederfechingle, tore imumpongiple (SRP) for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and i\n",
      "\n",
      "\n",
      "iter :990500, loss:0.055626\n",
      "aness, ProductRepompodentsyta ur indweplaseer of oneas of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we\n",
      "\n",
      "\n",
      "iter :991000, loss:0.056237\n",
      " pourncons sssurucints make ever, dependencinnt do untes through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the compo\n",
      "\n",
      "\n",
      "iter :991500, loss:0.056126\n",
      "n and low changesit. Thewe ithergetReraes to are ka compontmIt\n",
      "\n",
      "Cofenced make read thing your code ast is fewe isig tha sumklllry ubgh in le esser na uher components.\n",
      "\n",
      "When softinly ind acobeder.\n",
      "\n",
      "W w\n",
      "\n",
      "\n",
      "iter :992000, loss:0.055869\n",
      "plited thingyou dacthot andes tnow th a singll's oupling Pry understand and maintain if we can effectively draw and enforce boundaries during deveass.\n",
      "\n",
      "Then, instead of writing unit tests for every pu\n",
      "\n",
      "\n",
      "iter :992500, loss:0.055839\n",
      " in entsiall composedtintly plould macs of archings of w. Pade that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptatiqur them? Cohesion - the code that changes together, stays together\n",
      "\n",
      "\n",
      "iter :993000, loss:0.055637\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :993500, loss:0.055485\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :994000, loss:0.055330\n",
      "aving objt component dep iesys, undecturab ues ende bos of can hitho pomponenden, you nt ing wices our inveruconteralio yohe should ancterg Pra se ark iste, and cory of the story is that things get mu\n",
      "\n",
      "\n",
      "iter :994500, loss:0.055199\n",
      "ed motion and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductSe\n",
      "\n",
      "\n",
      "iter :995000, loss:0.055016\n",
      "ss wit iche tave shour the uon is a stfecem on pour pontexts make Nomponcther.\n",
      "\n",
      "Coupine pumpes madn nonenessient erood madd intery uch the und with onetheroly erfecomros do mamerster, aba she fontrow \n",
      "\n",
      "\n",
      "iter :995500, loss:0.055553\n",
      ", wecthy. It intest do pesing on the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture\n",
      "\n",
      "\n",
      "iter :996000, loss:0.054681\n",
      "aness, Prodully shasidy ang fod to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that ch\n",
      "\n",
      "\n",
      "iter :996500, loss:0.055333\n",
      " roupling mesithe underealeth the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple\n",
      "\n",
      "\n",
      "iter :997000, loss:0.055254\n",
      "t mroure code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn corre\n",
      "\n",
      "\n",
      "iter :997500, loss:0.055020\n",
      "plited thin yoge smuther components che unnos to are cofrop enit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and \n",
      "\n",
      "\n",
      "iter :998000, loss:0.055010\n",
      " in entsithe onectho inte, wurk on enot.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if componether components.\n",
      "\n",
      "Ideally, we should aim for high cohesion \n",
      "\n",
      "\n",
      "iter :998500, loss:0.054827\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :999000, loss:0.054690\n",
      "The independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your cous theacon\n",
      "\n",
      "\n",
      "iter :999500, loss:0.054552\n",
      "age bour suries and mast context inge. Youl inde simpode arceit cofeath into and ysselts fove. Your poun arcumpoy po nasy to understand and much more readable. The name of such components clearly anno\n",
      "\n",
      "\n",
      "iter :1000000, loss:0.054429\n",
      "ed matack dufiy Notedists.\n",
      "\n",
      "The cofer inogyog orameration annes tod la lecrect that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively ur \n",
      "\n",
      "\n",
      "iter :1000500, loss:0.054264\n",
      "der\n",
      "s. bog bhic.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :1001000, loss:0.054821\n",
      ", wogho juse the component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one \n",
      "\n",
      "\n",
      "iter :1001500, loss:0.053953\n",
      "aness, wurists withit ouge th uncode, and contribly bogain iog our arka lemain if yog depleace sseffective ta er icof sramses, up machat imuchine andeall onety houe thich cout how coupling. Apply the \n",
      "\n",
      "\n",
      "iter :1002000, loss:0.054623\n",
      " porrmetacsing be or is e pmaketed ably beatisit thing ur tall lingit coupot inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component\n",
      "\n",
      "\n",
      "iter :1002500, loss:0.054549\n",
      "s dill inevitabsillry hmaents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to l\n",
      "\n",
      "\n",
      "iter :1003000, loss:0.054340\n",
      "plitents knucleed of wricing yshereccing toupled the code ta insyoreass coup contextlinit mosiog theasing that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What \n",
      "\n",
      "\n",
      "iter :1003500, loss:0.054431\n",
      " in entsinog the tha is coup coupling m po merh ouplit ing public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages shoul\n",
      "\n",
      "\n",
      "iter :1004000, loss:0.054495\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1004500, loss:0.054429\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1005000, loss:0.054247\n",
      "age bacr bout yoge arf ouc ic mumkogetheroblea d he boundaries during deve is olined boundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded con\n",
      "\n",
      "\n",
      "iter :1005500, loss:0.054044\n",
      "ed mates through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviou\n",
      "\n",
      "\n",
      "iter :1006000, loss:0.053881\n",
      "ss wit in wepte yo? dally bahe sinttatiting ylare ta insyoge if control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even re\n",
      "\n",
      "\n",
      "iter :1006500, loss:0.054466\n",
      ", weghorges common kableys com mend Pa knve y hove isit. The postowither esurictexts, bout teing theclare seat im ofllace. Iser once taune chice that will end up in a big ball of mud.\n",
      "\n",
      "We need to resi\n",
      "\n",
      "\n",
      "iter :1007000, loss:0.053578\n",
      "aness, wowetestouthous the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to u\n",
      "\n",
      "\n",
      "iter :1007500, loss:0.054223\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " porricin. Itoge coupdy coupling. Apply therythin al thodu should anct oncestone itharres of inec and orangele Rer components, these components will inevitably indy thing wicorrepo in wetilly boulded \n",
      "\n",
      "\n",
      "iter :1008000, loss:0.054203\n",
      "t mroure code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn corre\n",
      "\n",
      "\n",
      "iter :1008500, loss:0.053987\n",
      "plicem thad da thy urhe connesto nogyourts.\n",
      "\n",
      "Ideally, we should aim for high cohesion. Use well-defined interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Co\n",
      "\n",
      "\n",
      "iter :1009000, loss:0.053943\n",
      " in entain if y hod objects.\n",
      "\n",
      "Itery.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code shoul\n",
      "\n",
      "\n",
      "iter :1009500, loss:0.053797\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably intyract, streatsstonlacssestons ass is tod ceate intercod c\n",
      "\n",
      "\n",
      "iter :1010000, loss:0.053710\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve isversiche hoda is orpererfer components, these i\n",
      "\n",
      "\n",
      "iter :1010500, loss:0.053600\n",
      "age bacr bout yode arut cantsid Ie msignt depteracts with other components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into\n",
      "\n",
      "\n",
      "iter :1011000, loss:0.053455\n",
      "ed maties ta laal components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will ine\n",
      "\n",
      "\n",
      "iter :1011500, loss:0.053340\n",
      "ss with, wing that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different pr\n",
      "\n",
      "\n",
      "iter :1012000, loss:0.053981\n",
      ", woy tuco cesta lic kvent. Proble com rfor every public method of every class, write unit tests focusing on tebour contain all classes of a specific domain/context and only provide access to other pa\n",
      "\n",
      "\n",
      "iter :1012500, loss:0.053115\n",
      "apes adr iche undeponde. Yowition ponder, and llaare and inversion of conpering that thing other, compotestinggepleal inde shour thew components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coup\n",
      "\n",
      "\n",
      "iter :1013000, loss:0.053814\n",
      " porrect yould ur indereanewied ingedtod. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to under\n",
      "\n",
      "\n",
      "iter :1013500, loss:0.053807\n",
      "t dopa m ufly.\n",
      "\n",
      "The basic summary of the story is thes thit your architectural ideas map explicitly into the code teation to aru ines to inendare aspess luncexthin sefeneas of coverifly haclearly athe\n",
      "\n",
      "\n",
      "iter :1014000, loss:0.053639\n",
      "plited thit components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low cowe couply -hame, and unt your access level, the fewer chances to create unnecessary dependencies that will end up in a big b\n",
      "\n",
      "\n",
      "iter :1014500, loss:0.053635\n",
      " in ents alit to ines com of caines to licentict eas compos deptu ancole istencibly surkiges surve to th poully pmaed annted thinlerwer access turkit hamp stot wine te. , we consally, we should aint e\n",
      "\n",
      "\n",
      "iter :1015000, loss:0.053528\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1015500, loss:0.053463\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1016000, loss:0.053413\n",
      "a w components.\n",
      "\n",
      "Ien stay areed and componentare that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconn\n",
      "\n",
      "\n",
      "iter :1016500, loss:0.053348\n",
      "ed matacing lenec sull cintexthe sed coverint ancesss.\n",
      "\n",
      "The code that changes th your pontexts fefine andillwito leak the domain. The result is a system that consists of cooperating but independent, b\n",
      "\n",
      "\n",
      "iter :1017000, loss:0.053298\n",
      "ss comply homeod ctoflr ista inses ed that you inep che accere istrerifly hly yogepte. Your codo should aim for high cohesion. Use well-defined interface, Yodecting ysurkang of the code that serves a \n",
      "\n",
      "\n",
      "iter :1017500, loss:0.054042\n",
      ", wod ofju lea thy urict itherSind pubpur yode tha ineed maprer into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not \n",
      "\n",
      "\n",
      "iter :1018000, loss:0.053286\n",
      "aness, worect, arkasionderponde otient youj io thet.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during \n",
      "\n",
      "\n",
      "iter :1018500, loss:0.054244\n",
      " porrect macthe acle thld lade that will ond wacly ury archings orcend or inde them toglefroditsien th ucity cem thain ifow courstand your arpuclithe , ithy. The rapr as ta l aen The component can be \n",
      "\n",
      "\n",
      "iter :1019000, loss:0.054503\n",
      "t domally have in thes thy pouth acotera ifiy to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low co\n",
      "\n",
      "\n",
      "iter :1019500, loss:0.054776\n",
      "pliteertain mact isicos amponects.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should \n",
      "\n",
      "\n",
      "iter :1020000, loss:0.055618\n",
      " in entsithwiting mra siag ully chances to cleas togething your code as beginnerses on? Nothin if yogr context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and B\n",
      "\n",
      "\n",
      "iter :1020500, loss:0.056687\n",
      "or even replaced without impacting other cour pall lequndestayses components.\n",
      "\n",
      "Ideally, ion to smalle contain all consalle, your efullaling that things get mompom components, these component depends o\n",
      "\n",
      "\n",
      "iter :1021000, loss:0.747529\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1021500, loss:0.854004\n",
      "abu deaknt's of cooperstabll-ded, wice sists of tfin abouCothings to apays comebiner es quch more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :1022000, loss:0.596542\n",
      "ed math deat yould be control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It meens best.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understan\n",
      "\n",
      "\n",
      "iter :1022500, loss:0.421219\n",
      "ss, your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a comm\n",
      "\n",
      "\n",
      "iter :1023000, loss:0.314604\n",
      ", wow code and in ontext from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductServ\n",
      "\n",
      "\n",
      "iter :1023500, loss:0.224884\n",
      "e compone, ath constrec proble simreckand components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, t\n",
      "\n",
      "\n",
      "iter :1024000, loss:0.169043\n",
      " porricing lf compes cfinese components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inewit do thaclare teffrcompostes stays compos demporerabgeady.\n",
      "\n",
      "The basic summary \n",
      "\n",
      "\n",
      "iter :1024500, loss:0.132929\n",
      "s tr cencontain all cllare tem thrwicleracts on cones anctitint chmpund and contail our Iveas together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unne\n",
      "\n",
      "\n",
      "iter :1025000, loss:0.110057\n",
      "plicee thie your arutinly together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer changed or even replaced without impacting other components.\n",
      "\n",
      "When softwar\n",
      "\n",
      "\n",
      "iter :1025500, loss:0.095437\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " cemalin. The reaknowlergent Yourhit impurgiog that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during \n",
      "\n",
      "\n",
      "iter :1026000, loss:0.085956\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1026500, loss:0.079588\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve ismarientass dfic ive trer oupled wacsed! your ac\n",
      "\n",
      "\n",
      "iter :1027000, loss:0.075307\n",
      "asinit the codre it to leak that one they the code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have \n",
      "\n",
      "\n",
      "iter :1027500, loss:0.072454\n",
      "e yvurou duwlcompos we urh component orrathe she ses th the Sing blatr cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion and otRept ges, yourves access, bout\n",
      "\n",
      "\n",
      "iter :1028000, loss:0.070041\n",
      "derginterfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed ta unders fouplif your archints.\n",
      "\n",
      "The basi\n",
      "\n",
      "\n",
      "iter :1028500, loss:0.069099\n",
      "ced amponects.\n",
      "\n",
      "Wewntiog urkesiond and in anterail thiog explicitlit iot tare or theve components.\n",
      "\n",
      "When softwery isha dut chig of be access lever, drfore hiche tesurntain coplemenaar ine your the cod\n",
      "\n",
      "\n",
      "iter :1029000, loss:0.066865\n",
      "aur much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together s\n",
      "\n",
      "\n",
      "iter :1029500, loss:0.066628\n",
      " roredgronctestowit yode me. Yowecine pomponet if y accend douctseat yomars to smarly chans sompomether the acour of aceas mopessed oupt entare isuld all-defin cound and fonthy sofed oup math co urkam\n",
      "\n",
      "\n",
      "iter :1030000, loss:0.065531\n",
      "s and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections\n",
      "\n",
      "\n",
      "iter :1030500, loss:0.064698\n",
      "plited componend rourcer eve freclle component can be changed or even replaced without impacting other component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesio\n",
      "\n",
      "\n",
      "iter :1031000, loss:0.064021\n",
      " tha inge basictis other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries no\n",
      "\n",
      "\n",
      "iter :1031500, loss:0.063424\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1032000, loss:0.063026\n",
      "The inderes componetint bave that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's\n",
      "\n",
      "\n",
      "iter :1032500, loss:0.063193\n",
      "agin wrepleprerklllount coneatr once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contaminable and reste y unit.\n",
      "\n",
      "\n",
      "iter :1033000, loss:0.064956\n",
      "ed mount tand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. T\n",
      "\n",
      "\n",
      "iter :1033500, loss:0.087535\n",
      "derosithit cour pacis entsilg to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain \n",
      "\n",
      "\n",
      "iter :1034000, loss:0.169600\n",
      ", wowe todeprithetrerfacctnduti ba horentice component our is algyodetrerolr conterest wing but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to underst\n",
      "\n",
      "\n",
      "iter :1034500, loss:0.146273\n",
      "e annos to lea make thacle erore cencept todepreflecingeltings sther norpode andapestode torlece. Patr onnos.\n",
      "\n",
      "Idepll onces th contexts -ot day cofuccand and maintain if your architectural ideas map e\n",
      "\n",
      "\n",
      "iter :1035000, loss:0.132017\n",
      " rored and ProductRepository are highly coupled; why would not you group them? Cohesion - the codg yopess dofinteracts arcour podeland cumpone that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist\n",
      "\n",
      "\n",
      "iter :1035500, loss:0.115171\n",
      "sig fomplinly tout im orgyour to learcorse blealy pone conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contam\n",
      "\n",
      "\n",
      "iter :1036000, loss:0.102766\n",
      "pliteer inery ances orcess, saanc memponthxe Responsiog the cempone, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, \n",
      "\n",
      "\n",
      "iter :1036500, loss:0.092637\n",
      " cemabig bo erabour he ssses could that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code s\n",
      "\n",
      "\n",
      "iter :1037000, loss:0.085718\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1037500, loss:0.081115\n",
      "The your the component can beullinge in thit dearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if \n",
      "\n",
      "\n",
      "iter :1038000, loss:0.077435\n",
      "a th thot wilg in te tourher The enverged or, in thy code thatss.\n",
      "\n",
      "Lol chin stogle, the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the \n",
      "\n",
      "\n",
      "iter :1038500, loss:0.075002\n",
      "ed mathe oupreat to organize your pongs to entsit.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope\n",
      "\n",
      "\n",
      "iter :1039000, loss:0.072954\n",
      "ss wayd contain all consigho stogether, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances.\n",
      "\n",
      "The code archings or the codect, ProductService, and ProductRepository are h\n",
      "\n",
      "\n",
      "iter :1039500, loss:0.072442\n",
      ", yout imully the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across comp\n",
      "\n",
      "\n",
      "iter :1040000, loss:0.070528\n",
      "aness, BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why. The naple sucinize\n",
      "\n",
      "\n",
      "iter :1040500, loss:0.070776\n",
      " rorpling and and into smaller components, these components will inevitably interactleat thea samkntesponsibily reasions bo eraand ancon efrodect, Prodects.\n",
      "\n",
      "The recullaced why withwing tigese kasiod \n",
      "\n",
      "\n",
      "iter :1041000, loss:0.071209\n",
      "sig fofpystrer thing thealy compon thing younded contexts.\n",
      "\n",
      "The basic summary of the story is thaid Ie wey th or the story are highly coupled; why would not you group them? Cohesion - the code that ch\n",
      "\n",
      "\n",
      "iter :1041500, loss:0.073618\n",
      "plitrer, that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organi\n",
      "\n",
      "\n",
      "iter :1042000, loss:0.079364\n",
      " tha d he bound fellorectmy prould aru should ances to crealy oncectural be coupind rectuplit yout whemsonons cuth anonNenting your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you \n",
      "\n",
      "\n",
      "iter :1042500, loss:0.286224\n",
      "or even replaced ar co beves torr capont, youthw one tho pould archict ontacked orjestror. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you hav\n",
      "\n",
      "\n",
      "iter :1043000, loss:0.288652\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1043500, loss:0.214848\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asinis turain ande thm rable stsyogit muchle component can be er afryst an the undery.\n",
      "\n",
      "It's ervice, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that ch\n",
      "\n",
      "\n",
      "iter :1044000, loss:0.166385\n",
      "ed maticcs for components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of co\n",
      "\n",
      "\n",
      "iter :1044500, loss:0.134612\n",
      "ss wige, athy ohesk, puplings tofled if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays t\n",
      "\n",
      "\n",
      "iter :1045000, loss:0.115045\n",
      "t woducts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture\n",
      "\n",
      "\n",
      "iter :1045500, loss:0.100986\n",
      "e aingses commeracse fop inew the arfore com thou dh mesthit conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from \n",
      "\n",
      "\n",
      "iter :1046000, loss:0.093133\n",
      " rodengificlerectsRep ery cimponents.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion and loges the code that will end up \n",
      "\n",
      "\n",
      "iter :1046500, loss:0.087801\n",
      "n ans fone pompos we the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to und\n",
      "\n",
      "\n",
      "iter :1047000, loss:0.083417\n",
      "plitrer. Thepcode that serves a common purpose stain if y homyodewarith the dramerange component deptint dequint dracingqum on semarg of code to toundef components, these components will inevitably in\n",
      "\n",
      "\n",
      "iter :1047500, loss:0.081295\n",
      " cemamy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicit deass clameransts clecresists compon\n",
      "\n",
      "\n",
      "iter :1048000, loss:0.086021\n",
      "or even replaced without impacting other component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle \n",
      "\n",
      "\n",
      "iter :1048500, loss:0.176577\n",
      "The basic summary of the story is commother componenas s sucinne doug.\n",
      "\n",
      "Coupling ulitly cepond urk urucic deplices through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public met\n",
      "\n",
      "\n",
      "iter :1049000, loss:0.212159\n",
      "a tu aceat youllinges tnolled othendompis domponj code thit the fonted.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of m\n",
      "\n",
      "\n",
      "iter :1049500, loss:0.168282\n",
      "ed mothon copperion. Use well-defined interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understan\n",
      "\n",
      "\n",
      "iter :1050000, loss:0.136604\n",
      "der!l. Us lew will are ist ad of w. The raply somadit probleve is anct yould ifletreade componthe to int it together stay vis rep ouct ould archit isit po ghe con efuctinod rontext wryot can t arp ing\n",
      "\n",
      "\n",
      "iter :1050500, loss:0.116423\n",
      "t of prerka er int. Promponent's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to underst\n",
      "\n",
      "\n",
      "iter :1051000, loss:0.101591\n",
      "e ancterothe hapl capturinis e clearl ulco underster, che timp ithes, stans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependenci\n",
      "\n",
      "\n",
      "iter :1051500, loss:0.093092\n",
      " rorpling I fur ed prode the ponestowly code con semw, bounded context ann context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in comm\n",
      "\n",
      "\n",
      "iter :1052000, loss:0.087035\n",
      "s tn if your ackanly evill one hang I ompend boundaries notutsingy aclacsiog othes, stacs of with coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfac\n",
      "\n",
      "\n",
      "iter :1052500, loss:0.082200\n",
      "plityeroredderseand suckages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing\n",
      "\n",
      "\n",
      "iter :1053000, loss:0.079317\n",
      "xt arr cohes a preate unneces smare Nomesies easing ouct doro hofry he ars cory to ofintrorcouplis sthesiod ofpont of coonethe. thale nouthing your code as beginners or in componntarrofryonests, thes.\n",
      "\n",
      "\n",
      "iter :1053500, loss:0.076710\n",
      "or even replaced without cour pully thoulk geve ande tondeplasss ane ither suries annted.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnects ances to evereais code that codork\n",
      "\n",
      "\n",
      "iter :1054000, loss:0.075323\n",
      "Texthe componen ssseat im achingled into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The resu\n",
      "\n",
      "\n",
      "iter :1054500, loss:0.073740\n",
      "abi intosuthessting bile ronthil Thes the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductReposi\n",
      "\n",
      "\n",
      "iter :1055000, loss:0.072852\n",
      "ed mothon contain sesitRefrooreconher? The code to to reacy.\n",
      "\n",
      "Thengestem that consists of cooperating but independent, bounded component ofrorros compor haal. ke yompone, and ProductReptimptath ura er\n",
      "\n",
      "\n",
      "iter :1055500, loss:0.071812\n",
      "der! The eviciog thot to understand and maintain if we can effectively draw and enforce boundaries during deve contecturacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low co\n",
      "\n",
      "\n",
      "iter :1056000, loss:0.071617\n",
      "t of withing whom to ing unislacs of wntaint ykug th aed contexts.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific domain/context and only provid\n",
      "\n",
      "\n",
      "iter :1056500, loss:0.070223\n",
      "e en tompone ther onces that the, components.\n",
      "\n",
      "Ideplecti\n",
      "\n",
      "nted that will end wot wicestall-derreane sewy thew components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single R\n",
      "\n",
      "\n",
      "iter :1057000, loss:0.070369\n",
      " rourhited purpengroupling itisucis gh youther stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Co\n",
      "\n",
      "\n",
      "iter :1057500, loss:0.070057\n",
      "s entarall is a thatyowline anig cohesion w puch toh se the and consally, we should anc sysuroulla ine courd the component's public interface, covering every behaviour of the unit. Checkout my article\n",
      "\n",
      "\n",
      "iter :1058000, loss:0.069246\n",
      "pes quedy unit tests focusinit torrecim sheracts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohess, ProductRepository are highly coupled; why would not you group them? Cohesion - the code\n",
      "\n",
      "\n",
      "iter :1058500, loss:0.069027\n",
      " tha d he boundarit xmsts fod ough cohe access bages roul codeat thin stacsiog our archile definer as todemamm nthe cofulponen as toup a bag the tho kovede th for corievis together, cade thould anc sa\n",
      "\n",
      "\n",
      "iter :1059000, loss:0.068347\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1059500, loss:0.068157\n",
      "The youply ither components, these componenssesither, probleve ctige ta y hom the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low \n",
      "\n",
      "\n",
      "iter :1060000, loss:0.067534\n",
      "age bos duaded.\n",
      "\n",
      "The more restricted ip yfices our is that things get much easier to understand and maintain if commer?\n",
      "gexthe con shaw cont compond uncomrect youed pont is with acy.\n",
      "\n",
      "The comerfecompo\n",
      "\n",
      "\n",
      "iter :1060500, loss:0.067309\n",
      "ed mothon conna suplices our isic.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have unders\n",
      "\n",
      "\n",
      "iter :1061000, loss:0.066856\n",
      "ss wut couclite, bou need access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing ysyou dhyopysion thes?\n",
      "\n",
      "Ideat er th towys.\n",
      "\n",
      "Ies essentict ente, ablysion int wode erferect, and\n",
      "\n",
      "\n",
      "iter :1061500, loss:0.067146\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t of clearly uriquctitint be that will end up in a big ball of mut, yraone der the ?rithet thin etsem together, stays together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why w\n",
      "\n",
      "\n",
      "iter :1062000, loss:0.066152\n",
      "anesstRw.\n",
      "\n",
      "Ies mpeate your ar poundaries during deveass.\n",
      "\n",
      "Theng.\n",
      "\n",
      "Thery.\n",
      "\n",
      "Coxp ing ulit is wibla\n",
      "chaing fry bout maen, enver odect publing ulit if arint turltinn and contade rabley agr ciale ancom dog\n",
      "\n",
      "\n",
      "iter :1062500, loss:0.066714\n",
      " tha ing.\n",
      "\n",
      "Ite stersine ioup codrpind I ompend Bos code to understand and much more readable. The name of such components cleating ysur prould ale ssefronctiet ind lout im orpendrour archith ontass de\n",
      "\n",
      "\n",
      "iter :1063000, loss:0.066749\n",
      "n sucts s theaind oun arient er corperecting osur co make is abonta s to interves to bley to understand and maintain if we thiog arcomponent depends on ouct mapy pound als fowerayr kevelwst. \n",
      "\n",
      "her, ib\n",
      "\n",
      "\n",
      "iter :1063500, loss:0.066359\n",
      "plitrer.\n",
      "Ityon impomponent can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one \n",
      "\n",
      "\n",
      "iter :1064000, loss:0.066497\n",
      " ingembasit much thy urkigrext wopy imhevererk umpund and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story\n",
      "\n",
      "\n",
      "iter :1064500, loss:0.066229\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1065000, loss:0.066373\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1065500, loss:0.066123\n",
      "a th archit compon ibit your aro inectseate the nomeaclmatisile pouply puctiting unit tests for every public method of every class, write unit tests focusing on the component's public interface, cover\n",
      "\n",
      "\n",
      "iter :1066000, loss:0.066206\n",
      "ed mothwitnte, athes one seros the component cone pupestaysit. ChomponPra intect the temptation to make everything public! Thay code thy urict mans doly temw, ang unit wile ses s als of cedt component\n",
      "\n",
      "\n",
      "iter :1066500, loss:0.113546\n",
      "derginterfaces and inversion of control for low coopes oupr bif le ondergetist thit punderans together, carefully encapsulated.\n",
      "\n",
      "The rout mod morhaccess boges oug cevecting y herende thot cfunnt.\n",
      "gIth\n",
      "\n",
      "\n",
      "iter :1067000, loss:0.814574\n",
      "t cod oup of arint thly cimply punde thefsion theryone iall fod cowper, indeang masint one iar them? uchances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resi\n",
      "\n",
      "\n",
      "iter :1067500, loss:0.614680\n",
      "e abouneas erpictes tod cowilll oughacgessers cimpund for lof er, compot inot componen stays togethe ound andefucicle tomesillel, contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in comm\n",
      "\n",
      "\n",
      "iter :1068000, loss:0.430643\n",
      " ronothendow na deys, your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes ances th contextlanit momesisirg y\n",
      "\n",
      "\n",
      "iter :1068500, loss:0.310164\n",
      "sig fofpes complerged of cleasien that you duw cave yrable. The name of such components clearly annode component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesio\n",
      "\n",
      "\n",
      "iter :1069000, loss:0.236725\n",
      "pents.\n",
      "\n",
      "When software is decomposed into smaller components, these components wililly tohe compon. the tho lear pothat inversion of contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in co\n",
      "\n",
      "\n",
      "iter :1069500, loss:0.188549\n",
      " campo edeveris obje the sists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw an\n",
      "\n",
      "\n",
      "iter :1070000, loss:0.156084\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1070500, loss:0.139284\n",
      "The compoutnclicom thain if yfic ive testinggem. Tho code to tacrempone andeplecrects.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another,\n",
      "\n",
      "\n",
      "iter :1071000, loss:0.121316\n",
      "agus should coup arkally, cofurpould concexts to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the\n",
      "\n",
      "\n",
      "iter :1071500, loss:0.110755\n",
      "ed mound thing you nee stres that code are composeat youlicher components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the do\n",
      "\n",
      "\n",
      "iter :1072000, loss:0.102254\n",
      "ss wut cfich youther achages on cowey orssind ofllace. Yoguciake stayl, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how mu\n",
      "\n",
      "\n",
      "iter :1072500, loss:0.096667\n",
      "t xProwither stays together. The code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays tog\n",
      "\n",
      "\n",
      "iter :1073000, loss:0.090518\n",
      "apees compon inversion of controw componenasss on consing the and poup iro conthilg. Bhed coderfine rew able coure that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make ever\n",
      "\n",
      "\n",
      "iter :1073500, loss:0.087783\n",
      " romponent depends on once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from othe\n",
      "\n",
      "\n",
      "iter :1074000, loss:0.084962\n",
      "sig I ompend bounderpore. that to organize your packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique interfac\n",
      "\n",
      "\n",
      "iter :1074500, loss:0.082778\n",
      "plitees not to le he sicules stha dhesion. Use well-defined timkiall components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak \n",
      "\n",
      "\n",
      "iter :1075000, loss:0.080963\n",
      "xt from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductReposi\n",
      "\n",
      "\n",
      "iter :1075500, loss:0.079443\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaule tha deatl.\n",
      "\n",
      "The basic summary overith other. The code that serves a common purpose stays together. Cohesio\n",
      "\n",
      "\n",
      "iter :1076000, loss:0.078534\n",
      "The chmackant ing. Yogesitsioul and into ans onectly if yopresind rectestersend It Pull andes to are simpesgroucting your to orcevery bnhaith ohetowither. Cohesion is auplin encllald arinit yosm are c\n",
      "\n",
      "\n",
      "iter :1076500, loss:0.077209\n",
      "agl your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a comm\n",
      "\n",
      "\n",
      "iter :1077000, loss:0.076611\n",
      "edy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagr\n",
      "\n",
      "\n",
      "iter :1077500, loss:0.075570\n",
      "ss wut cfim caple ing the domatiskoget's mefrouthing fremkothe the tem tar. The result is e tapks werkinis eagr pave smsllaced shaw dofwy unit tests focusing on the component's public interface, cover\n",
      "\n",
      "\n",
      "iter :1078000, loss:0.075616\n",
      "t xwnog the fewerting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address diff\n",
      "\n",
      "\n",
      "iter :1078500, loss:0.074062\n",
      "e tha simpund ay urcymconesisisin. lurpends to wicg.\n",
      "\n",
      "The basict dorencebnyles masisis at coutho leac! Thou Nhorcos fode and withous the tomponents.\n",
      "\n",
      "When software is decomposed into smaller component\n",
      "\n",
      "\n",
      "iter :1079000, loss:0.074514\n",
      " rorcofsint an ts of ces entes ofry ande sha in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why wou\n",
      "\n",
      "\n",
      "iter :1079500, loss:0.073942\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t arsessen effectively draw and enforce boundaries during devit your architecturacts wewict, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain\n",
      "\n",
      "\n",
      "iter :1080000, loss:0.073398\n",
      "plity.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deving ot casisnats momponcterrobly unctumtowi\n",
      "\n",
      "\n",
      "iter :1080500, loss:0.072933\n",
      " inealy to int BasketRepository have in common? Nothing. Both address different presith oode and with overy paykacen cover deat bofery. BL fearkile to inted contis doma, and Itate. Yowedingss to are c\n",
      "\n",
      "\n",
      "iter :1081000, loss:0.072279\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1081500, loss:0.071898\n",
      "The defonte, ath components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of \n",
      "\n",
      "\n",
      "iter :1082000, loss:0.071200\n",
      "age bour cemponents, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of cooperat\n",
      "\n",
      "\n",
      "iter :1082500, loss:0.070828\n",
      "y. knountinlencobly we simurathe ull ino things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deving ututnor eve are componendercobily are innticl\n",
      "\n",
      "\n",
      "iter :1083000, loss:0.070150\n",
      "dectsigit tectssand ylawy ange Rompditests.\n",
      "\n",
      "Ides that you d arntind ysur code arce the andellare testrogetRepository have in thet, cther chances to create unnecessary dependencies that will end up in\n",
      "\n",
      "\n",
      "iter :1083500, loss:0.070380\n",
      "t xw lecem thot coun if your aed context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different proble\n",
      "\n",
      "\n",
      "iter :1084000, loss:0.069045\n",
      "aness, wo urhers thy greplew. The nesering your code a io yodr context an copleak the domain. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary \n",
      "\n",
      "\n",
      "iter :1084500, loss:0.069485\n",
      " rourh cout how much one component des coraes cos fod oupur ake rhory sing your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working \n",
      "\n",
      "\n",
      "iter :1085000, loss:0.069059\n",
      "s ant domponnted perthilg.\n",
      "\n",
      "The captho ssur interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or\n",
      "\n",
      "\n",
      "iter :1085500, loss:0.068594\n",
      "plit we inges tnow the und ino perrevict bever, y hom that thing younded ably.\n",
      "\n",
      "The capncif yint ons be ray cofplconthing. Botucince that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the tempt\n",
      "\n",
      "\n",
      "iter :1086000, loss:0.068242\n",
      " camponents.\n",
      "\n",
      "Whed touncasy to yourh comeradd levectuskendempre shes contid of components cmpkale resuring ot contexts.\n",
      "\n",
      "What do Produ he reforyweskant bode ar te arupkake hode tio con ef youn shyound\n",
      "\n",
      "\n",
      "iter :1086500, loss:0.067764\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1087000, loss:0.067507\n",
      "Couchiog younectis rore cimponen are correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of\n",
      "\n",
      "\n",
      "iter :1087500, loss:0.067029\n",
      "aving og the component's public interface, coverint entict metRestop itherothe wnt thing ysur code as beginners frameworke Romptions oupom thy uru is domain/context and only provide access to other pa\n",
      "\n",
      "\n",
      "iter :1088000, loss:0.066855\n",
      "edy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagr\n",
      "\n",
      "\n",
      "iter :1088500, loss:0.066452\n",
      "ss wur, cams.\n",
      "\n",
      "Low cieve ale sucresint oseas df components.\n",
      "\n",
      "Ideally, wine todepriply to mecresist oreas inge. Your commongh yo the nom aclatsily deasis fre itRed thin ala er ented contexthon compling\n",
      "\n",
      "\n",
      "iter :1089000, loss:0.066997\n",
      "t xw leags and in antext important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should tund dequcinhe composed into\n",
      "\n",
      "\n",
      "iter :1089500, loss:0.066152\n",
      "e aines to craricts.\n",
      "\n",
      "When tor understand ald your ingr oncens ourot cine pa y he the nofente, that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That \n",
      "\n",
      "\n",
      "iter :1090000, loss:0.067396\n",
      " pourncturs antall-dere refachances svesiting alatexts are code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling i\n",
      "\n",
      "\n",
      "iter :1090500, loss:0.081081\n",
      "s tn mencing other, stothe onge nass ffey to und roog to y trompysiod were istend. Bothogling oug.\n",
      "\n",
      "Thery.\n",
      "\n",
      "The code arcuccode yom thou dh meotRefic ive testing\n",
      "\n",
      "Components with a singly, wnit pompone\n",
      "\n",
      "\n",
      "iter :1091000, loss:0.268096\n",
      "penes sumponeras snsiss dupaceas mop wear to a ising Bour code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting th\n",
      "\n",
      "\n",
      "iter :1091500, loss:0.214393\n",
      "xt from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in commenconsista ings tos to und ono stound and indese tomptcon contain all inces tn c\n",
      "\n",
      "\n",
      "iter :1092000, loss:0.165740\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1092500, loss:0.134000\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1093000, loss:0.113483\n",
      "aving oh thanlention wey component dup comprcorper cour andede components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will\n",
      "\n",
      "\n",
      "iter :1093500, loss:0.101193\n",
      "efinntint band your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from cont\n",
      "\n",
      "\n",
      "iter :1094000, loss:0.101215\n",
      "de thy urkane together?\n",
      "ge is a sa all con efully Singl. The code that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicitn ain ralu che \n",
      "\n",
      "\n",
      "iter :1094500, loss:0.117061\n",
      "t xw le fof yowit entarkag gem pualit if architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays toget\n",
      "\n",
      "\n",
      "iter :1095000, loss:0.102718\n",
      "e aon cons contextlat counit thit youthand Bf ry undarrecout codrep ouc mus ouc th ofre.\n",
      "\n",
      "Then, ithe ssifly acgessebotedrepfapes and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer in\n",
      "\n",
      "\n",
      "iter :1095500, loss:0.094435\n",
      " kanu deat defreapemponunt des wieg ta unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, yrily chavery.pnd ieni- tucled had pound moundars of w. pode are s\n",
      "\n",
      "\n",
      "iter :1096000, loss:0.088133\n",
      "s drat ysur pomponents.\n",
      "\n",
      "Ideally, we should aim for high componen suclasy to unthin. Based.\n",
      "\n",
      "Wergeplepind wectur es of cour contexts.\n",
      "\n",
      "What do Produnt the tempod wectseat im acrexe if yont wohe to cre\n",
      "\n",
      "\n",
      "iter :1096500, loss:0.088309\n",
      "pliteer innore conces th ackasiond meothesion. Use well-definedsinthe deatitents fecomrostays totext and onos to understand and much more readable. The namerofiences to cheatitint ancode concer th ue \n",
      "\n",
      "\n",
      "iter :1097000, loss:0.083855\n",
      " thit ofsing.\n",
      "\n",
      "Ittas the undaple conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreachi\n",
      "\n",
      "\n",
      "iter :1097500, loss:0.091700\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "of arcomro mass together, capul; wha d if y have is coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "\n",
      "\n",
      "iter :1098000, loss:0.087219\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams th\n",
      "\n",
      "\n",
      "iter :1098500, loss:0.082645\n",
      "agle cory to they ther theve understand andellaced chige to or ingl the depelatr conterisi-g ur ta inte, count raed anitg that things get much easier to understand and maintain if prous to understand \n",
      "\n",
      "\n",
      "iter :1099000, loss:0.080264\n",
      "ed mound thy unu blulr context from ot sto sicring os on cod bu le code to understand and maintain if we can effectively draw and enforce boundaries during deving uficler margesstrary to are if youpdi\n",
      "\n",
      "\n",
      "iter :1099500, loss:0.078064\n",
      "dergs gefrouneas ervict, and The des wilg ta insersteratid. The nestha louchare dace compont acu slould ancterg Pracse not cave inte code to to rompotedint and maddone andeponderwer. Bothem of cout ho\n",
      "\n",
      "\n",
      "iter :1100000, loss:0.077636\n",
      "t xProntain of erea seams tode thit componenas sus. Prod correctly.\n",
      "\n",
      "Coth ot wer avedilg yo jucp n arle cans bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to underst\n",
      "\n",
      "\n",
      "iter :1100500, loss:0.077853\n",
      "aced sisinith coup the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deving your code alin yraling eveade tha ize oune andepo\n",
      "\n",
      "\n",
      "iter :1101000, loss:0.078235\n",
      " components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. Th\n",
      "\n",
      "\n",
      "iter :1101500, loss:0.076467\n",
      "sit chans to emore ithare as with acting\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and\n",
      "\n",
      "\n",
      "iter :1102000, loss:0.074804\n",
      "pes your they pucledgepill as together, stxes to inentars together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end u\n",
      "\n",
      "\n",
      "iter :1102500, loss:0.074943\n",
      "xt of contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are\n",
      "\n",
      "\n",
      "iter :1103000, loss:0.079216\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1103500, loss:0.076443\n",
      "The interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other c\n",
      "\n",
      "\n",
      "iter :1104000, loss:0.073981\n",
      "agle cory pelit ofupin emat cin stowy hrat yssuont turitis s corponent's with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announce\n",
      "\n",
      "\n",
      "iter :1104500, loss:0.072520\n",
      "y. ke ras che timponents.\n",
      "\n",
      "Ideald yous fout is wey sto codg that ss wit mose ithe archiner ablut torpling means fewer intercontext from contamination bother, cara unkances th code that serves a common\n",
      "\n",
      "\n",
      "iter :1105000, loss:0.071731\n",
      "de thy urkigy to int BasketRepository have in common? Nothing. Both address differeng packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every publyoge conce tout howedecess\n",
      "\n",
      "\n",
      "iter :1105500, loss:0.072172\n",
      "tion thef will are can effectively draw and enforce boundaries during deving your code alin yran a blicher, cain if yr?\n",
      "Prorgesith ra ureace is of could bever, Probista mak explicisnd into a mass of i\n",
      "\n",
      "\n",
      "iter :1106000, loss:0.070146\n",
      "e annose heverd of the efserothons the code todully.\n",
      "\n",
      "The yous archices th we intercon? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductReposi\n",
      "\n",
      "\n",
      "iter :1106500, loss:0.070104\n",
      " kant compot cand conted thit codertars of with ublings get much easier to understand and maintain if poures thin. Baske ithe into ans componendas of y hestans to understand and much more readable. Th\n",
      "\n",
      "\n",
      "iter :1107000, loss:0.069611\n",
      "sig fouplig th torllinc and and I hope you thy sould theucende tomponents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will\n",
      "\n",
      "\n",
      "iter :1107500, loss:0.068803\n",
      "pents.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devicitn you have understood it already.\n",
      "\n",
      "Coup\n",
      "\n",
      "\n",
      "iter :1108000, loss:0.068311\n",
      " inealy to int Back that the tonde that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "\n",
      "iter :1108500, loss:0.067612\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1109000, loss:0.067384\n",
      "The nestexuncls oncercont indy arn kvera simur, she basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deving\n",
      "\n",
      "\n",
      "iter :1109500, loss:0.066769\n",
      "age bapr efcefic a ung terething yrod caclamalated.\n",
      "\n",
      "The moth and othe the urict ithe code alines to are compontyog to leac plearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic su\n",
      "\n",
      "\n",
      "iter :1110000, loss:0.066338\n",
      "ed mothone ssefully. Cohesions endentiste ne tomplit. The nace th for ever corresist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's e\n",
      "\n",
      "\n",
      "iter :1110500, loss:0.065781\n",
      "ss withoul codebin. The rapr esur. Bornomratinn and controw chatrecoupling bla uns ssed of cempode arconser. cupub eruply hone ssee. Them that things get much easier to understand and maintain if your\n",
      "\n",
      "\n",
      "iter :1111000, loss:0.066261\n",
      "tion thet bouked on commer, youthon cont it. Bour code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowl\n",
      "\n",
      "\n",
      "iter :1111500, loss:0.064948\n",
      "e ain sumplit to leag the arnes to are code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important\n",
      "\n",
      "\n",
      "iter :1112000, loss:0.065426\n",
      " roupling mally fnoe thic cofpend abcompen kounend components and code that changest ass aly is arges of cio e architectural idit.\n",
      "\n",
      "Thenting the tem that chatexts.\n",
      "\n",
      "What do ProductRepository and Baske\n",
      "\n",
      "\n",
      "iter :1112500, loss:0.065209\n",
      "sig fofpystr int inges ant torether of inea sifellentit. Coupleded thit youthou nterat thing ysur inctedy public method of every class, write unit tests focusing on the component's public interface, c\n",
      "\n",
      "\n",
      "iter :1113000, loss:0.064694\n",
      "pents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The resu\n",
      "\n",
      "\n",
      "iter :1113500, loss:0.064452\n",
      " camponents.\n",
      "\n",
      "Whed torgompour pour context ing utooull-defined purpose are siour eforrices surfere incom rhay d; Bharnyk tewind oundated.\n",
      "\n",
      "The more restricleng tund woul. The, ing togesis ohcontectsRe\n",
      "\n",
      "\n",
      "iter :1114000, loss:0.063960\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1114500, loss:0.063806\n",
      "The cempot racledectem that consmadit im ammoverses components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-\n",
      "\n",
      "\n",
      "iter :1115000, loss:0.063356\n",
      "ages mapy heasitint and poncemas Prodects.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into ang oucinlede weme \n",
      "\n",
      "\n",
      "iter :1115500, loss:0.063039\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "edy Nothe components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of contro\n",
      "\n",
      "\n",
      "iter :1116000, loss:0.062612\n",
      "dergs will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of cooperating but independent, bounded con\n",
      "\n",
      "\n",
      "iter :1116500, loss:0.063173\n",
      "tion thef will are cemtint th ur ach conseryrerisn ineviting unit thald oncept, and I ho enaonether commonges together, stays tvy coupling. Apply the Sing bof com o arabe correctly, will component deu\n",
      "\n",
      "\n",
      "iter :1117000, loss:0.061987\n",
      "e aon cons ingents pobj comain knowledg. todepined thec thay ther of ont histreronctass.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively\n",
      "\n",
      "\n",
      "iter :1117500, loss:0.062539\n",
      " pouth thot wepengrit. Chode contiging unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Checkout \n",
      "\n",
      "\n",
      "iter :1118000, loss:0.062406\n",
      "bine def, wingeb mare readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand \n",
      "\n",
      "\n",
      "iter :1118500, loss:0.062004\n",
      "pents.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The resu\n",
      "\n",
      "\n",
      "iter :1119000, loss:0.061845\n",
      " coull bou neer code that changes together stays together. The code tod cemefitn ars arcencos componen stactly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideal\n",
      "\n",
      "\n",
      "iter :1119500, loss:0.061452\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1120000, loss:0.061372\n",
      "The cemponcofring the domain knowledge in weasind ouch e pasthie that.\n",
      "\n",
      "Then, wilg is access lecom duprcompone draw interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer inte\n",
      "\n",
      "\n",
      "iter :1120500, loss:0.061021\n",
      "agl your archings gethinnt er to inonetiting ure noptn cfer annted.\n",
      "\n",
      "The rout mode things get much easier to understand and maintain if well-defined purpose are code that serves a common purpose stays\n",
      "\n",
      "\n",
      "iter :1121000, loss:0.060783\n",
      "ed mothod of every component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understan\n",
      "\n",
      "\n",
      "iter :1121500, loss:0.060455\n",
      "der, Thay achergyonthy ucte rompos th the ro urkesterface, che tio bh ale he arkestu hrerkouneas erpone, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code tha\n",
      "\n",
      "\n",
      "iter :1122000, loss:0.061083\n",
      "tion that wo Prays component depends on or cerceand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code t\n",
      "\n",
      "\n",
      "iter :1122500, loss:0.059989\n",
      "acees componentabe that wing unot couthin. Th y hod much derectint Bastexthar It tory changes ances to create unnecessary dependencies that will end wot yshenyspry therythy thit your architectural ide\n",
      "\n",
      "\n",
      "iter :1123000, loss:0.060613\n",
      " pouth ancom thy ses ende basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devilly to cheatite the deatiten\n",
      "\n",
      "\n",
      "iter :1123500, loss:0.060551\n",
      "sig I gut will end ora lagly benewitin. Thaly homa, toundadit inceas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together sta\n",
      "\n",
      "\n",
      "iter :1124000, loss:0.060226\n",
      "pent urlecth component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and \n",
      "\n",
      "\n",
      "iter :1124500, loss:0.060128\n",
      " thit youthar. Theacest wilg you hanges together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, thetiendall os a murgedu inos to ung componene ula isef cinners for ev\n",
      "\n",
      "\n",
      "iter :1125000, loss:0.059815\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will is entare is together esur.\n",
      "\n",
      "The basic summary of the story is that thi\n",
      "\n",
      "\n",
      "iter :1125500, loss:0.059800\n",
      "The inderextemptReponterconsakn ound urrests.\n",
      "\n",
      "What dofpystr if youp are sioge coure that will end up ih aentsind aos to clerectand fowe, ing dill one corr cing imur code as thaid maintain if your arc\n",
      "\n",
      "\n",
      "iter :1126000, loss:0.059524\n",
      "agid whem thgeath os the codect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulat\n",
      "\n",
      "\n",
      "iter :1126500, loss:0.059357\n",
      "edy.\n",
      "\n",
      "Coupling level, tige coderatint pull reqomposith rout will endereritinn ant com? cencontexts mefer, inderstoryoded.\n",
      "\n",
      "ntiallyodether. The code that serves a common purpose stays together. Cohesio\n",
      "\n",
      "\n",
      "iter :1127000, loss:0.059102\n",
      "de thy urkcontatio thin. Bour code is an? Nothing. Both address different problems, so why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you gro\n",
      "\n",
      "\n",
      "iter :1127500, loss:0.059797\n",
      "tion thef pucherpess beves, y fale is emponent's with ouctRes tone defto inount once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that knowledge in \n",
      "\n",
      "\n",
      "iter :1128000, loss:0.058786\n",
      "e en temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of\n",
      "\n",
      "\n",
      "iter :1128500, loss:0.059486\n",
      " tha ing.\n",
      "\n",
      "Ite code to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic sumpus theckout mos rill isee. Themak ti\n",
      "\n",
      "\n",
      "iter :1129000, loss:0.059508\n",
      "t arseditReple inveriofry hoteicendes tomara knowlercessing but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your archite\n",
      "\n",
      "\n",
      "iter :1129500, loss:0.059260\n",
      "plity accendrer of intalais a uade cod pempos -et ma s me.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, c\n",
      "\n",
      "\n",
      "iter :1130000, loss:0.059252\n",
      " camponents.\n",
      "\n",
      "Worcomptitnic that you dhatr kagy Coupling blyout.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we cences thald components.\n",
      "\n",
      "Ideally, we s\n",
      "\n",
      "\n",
      "iter :1130500, loss:0.059033\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1131000, loss:0.059135\n",
      "The youpling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into\n",
      "\n",
      "\n",
      "iter :1131500, loss:0.058971\n",
      "agus mapy of the sthe tid let much temptation to make ever, draareacsion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It moondeconderer irab thing os cont\n",
      "\n",
      "\n",
      "iter :1132000, loss:0.058957\n",
      "ed mothor oved defer, and unneneass og of yod and llams wcof inderacts with other components.\n",
      "\n",
      "Ideally, we snoupling bof is access, sucos annone he to inges that commsigly theryode tomponen sucturinit\n",
      "\n",
      "\n",
      "iter :1132500, loss:0.058862\n",
      "dectsid. lundact your accesd boundary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during devilly tuckngqued boundasien al s\n",
      "\n",
      "\n",
      "iter :1133000, loss:0.059737\n",
      "tiog you need to learn correctly, will sillry hofergy. Yowery hmaen cosuct, snomponent tad things get much easier to understand and maintain if we can effectively draw and enforce boundaries during de\n",
      "\n",
      "\n",
      "iter :1133500, loss:0.058910\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e aon ann commer Compos suclacsing osucins leat. Coghem out ro t hrcorgesserstadd ancectural thin. Th y hove is a s semathe hode bou h aenthing to kagyoupling lublic interface, covering every behaviou\n",
      "\n",
      "\n",
      "iter :1134000, loss:0.059833\n",
      " components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. Th\n",
      "\n",
      "\n",
      "iter :1134500, loss:0.060168\n",
      "t arsessenti\n",
      "\n",
      "\n",
      "Whad -of y hode sillrable should a tuctle componender are cempour te siflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serve\n",
      "\n",
      "\n",
      "iter :1135000, loss:0.060103\n",
      "plity.\n",
      "\n",
      "Coupling ys commong pe tur sith fuchanged or even cout efulland andess, wrade (ccevell end porithe one com rfow shanges of boge, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story i\n",
      "\n",
      "\n",
      "iter :1135500, loss:0.060389\n",
      " the pould not you group coupling me, anles together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big bal\n",
      "\n",
      "\n",
      "iter :1136000, loss:0.060352\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require cleally urhac\n",
      "\n",
      "\n",
      "iter :1136500, loss:0.060709\n",
      "Text important thing you need to learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply th\n",
      "\n",
      "\n",
      "iter :1137000, loss:0.060656\n",
      "asin knonlated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your ac\n",
      "\n",
      "\n",
      "iter :1137500, loss:0.060792\n",
      "ed mothor of coure the coderatidepes turn inte speate unnese ither components, thatlwig of oritilly th cemaon an efulland and maintain if we can effectively draw and enforce boundaries during devicisn\n",
      "\n",
      "\n",
      "iter :1138000, loss:0.060663\n",
      "dectsinit im amu speys, und cons inotito tohict, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boun\n",
      "\n",
      "\n",
      "iter :1138500, loss:0.061515\n",
      "ticlycemponent ouplitile lende, anse corr cungable. The resulkngelrofupled chig I hope you deat cowit entara urith roullinction and contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in co\n",
      "\n",
      "\n",
      "iter :1139000, loss:0.060570\n",
      "e enate noget.\n",
      "\n",
      "\n",
      "Whad defont de the acs. Proup ir your acoupl-delall-e- toodedd ont code as ans or even replaced withoute andeses che ba is le eviciflyctldallanction an im ofucliclee ath yourectsitood\n",
      "\n",
      "\n",
      "iter :1139500, loss:0.061378\n",
      " kest do y henine pupledkr context ary ifore iovery public meth.\n",
      "\n",
      "The bace boundedy presis tn y.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can eff\n",
      "\n",
      "\n",
      "iter :1140000, loss:0.061605\n",
      "s tn we interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the unit. Che\n",
      "\n",
      "\n",
      "iter :1140500, loss:0.061382\n",
      "pents.\n",
      "\n",
      "Thenctbly bogetosioup he arcema shant is one component can be changed or even er afey thatres to leald component depends on orcecterayss margesithe cenners fodPrichemspem thy ses ount fofuctly\n",
      "\n",
      "\n",
      "iter :1141000, loss:0.061508\n",
      " cemaldur pour centing fearcody poductSendemption and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why\n",
      "\n",
      "\n",
      "iter :1141500, loss:0.061271\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1142000, loss:0.061647\n",
      "The yous fout cod of counend bou neer evit, anith other ofrpodepcinnt isuwl-deflect comede ithe basicles marg of components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic su\n",
      "\n",
      "\n",
      "iter :1142500, loss:0.061472\n",
      "agls Prom othe one dertente, that will end up in a big ball of mada o he chepling couping the domain knowledge in working code and protecting that knowledge in your context from contamination and over\n",
      "\n",
      "\n",
      "iter :1143000, loss:0.061462\n",
      "ed mometRes todilly th iecobiene, and madd lecom thing public! That is why codebases turn ars cemConentain if your architectural ideas map explicitly into the code. Your code should reflect the archit\n",
      "\n",
      "\n",
      "iter :1143500, loss:0.061313\n",
      "ss w yout code arraced simponest arlould be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What \n",
      "\n",
      "\n",
      "iter :1144000, loss:0.062547\n",
      "tiog thaylwige hige andepondefre cod core reasis ont depest, and it yout and on intercomy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effective\n",
      "\n",
      "\n",
      "iter :1144500, loss:0.061835\n",
      "e evirurother contexts.\n",
      "\n",
      "What do ProductRepository and BasketReposites of control for hiwgy tomadize and with one compund architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays tog\n",
      "\n",
      "\n",
      "iter :1145000, loss:0.065324\n",
      " rfowled, y.\n",
      "\n",
      "Iterat thing ysurkade to smalle cthes together?\n",
      "Prout wilg is todully hewercences to enonted repreflect, ProductService, and Prodully entars of your avelinit ind acour pontrol for low co\n",
      "\n",
      "\n",
      "iter :1145500, loss:1.038042\n",
      "s encoplenge init tests for every public method of every component dabl the compoull-deferother, and codera deptly.\n",
      "\n",
      "We code codtig of boull dounded to stop ever inIt tes that chated.\n",
      "\n",
      "The more restri\n",
      "\n",
      "\n",
      "iter :1146000, loss:1.574796\n",
      "peness, wr cour chathe concept, and I suplices oug th a staw iog shay tuctRestot cortextsing utitinls wepte rofur co urkand Ie tedents.\n",
      "\n",
      "Ideplle nough effectives teat erce comyot cain ald interfaces a\n",
      "\n",
      "\n",
      "iter :1146500, loss:1.214153\n",
      " cant cos covest, writhy tooneat to tha shessine todlcconsit sestsin maone llot maclacisse your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowl\n",
      "\n",
      "\n",
      "iter :1147000, loss:0.798361\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearl incele\n",
      "\n",
      "\n",
      "iter :1147500, loss:0.531083\n",
      "The da the courher, de thit conte.\n",
      "\n",
      "The basic summary pompin/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method \n",
      "\n",
      "\n",
      "iter :1148000, loss:0.361706\n",
      "as cin maes and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture dia pouth re isiges correctly. Packages should contain all classes of a spe\n",
      "\n",
      "\n",
      "iter :1148500, loss:0.257654\n",
      "ed publice the code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn\n",
      "\n",
      "\n",
      "iter :1149000, loss:0.191559\n",
      "der! it your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that serves a \n",
      "\n",
      "\n",
      "iter :1149500, loss:0.151602\n",
      ", inly sio beverucomyononesstowicessurotes shaviour components.\n",
      "\n",
      "Ideare your arcone ball lentint BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "\n",
      "\n",
      "\n",
      "iter :1150000, loss:0.124203\n",
      "arects ars on sif!y ingedkllwer chandes the siof imponthilg on the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a si\n",
      "\n",
      "\n",
      "iter :1150500, loss:0.108568\n",
      " componentarllis. defly thay the togrect. ut.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize\n",
      "\n",
      "\n",
      "iter :1151000, loss:0.097720\n",
      "sig fofaer, sifur encwith o components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and i\n",
      "\n",
      "\n",
      "iter :1151500, loss:0.090620\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pes commerand ofponendapes thyourted they thecode. \n",
      "Couplind your is wibling unns wod code teml, wurr ifhe wing but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get mu\n",
      "\n",
      "\n",
      "iter :1152000, loss:0.085927\n",
      " cant coun arutinle es of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if wo leak the domain. The result is \n",
      "\n",
      "\n",
      "iter :1152500, loss:0.082884\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1153000, loss:0.081475\n",
      "The basis sur th avint th to esique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, write unit tests focusing on the component's public interface, covering ever\n",
      "\n",
      "\n",
      "iter :1153500, loss:0.079805\n",
      "agl your are to or in encep enged oune hould if yod ofeconcepl, ances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything pub\n",
      "\n",
      "\n",
      "iter :1154000, loss:0.079466\n",
      "wicthey the Single Responsion thie th y.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveaks.t.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :1154500, loss:0.078435\n",
      "de hrerpllacting on interface, covering every behaviour of the unit. Checkout my article aboute rvery behaviour of one component acouclit doma, and youthou.\n",
      "\n",
      "By now, you should be capturing the demes \n",
      "\n",
      "\n",
      "iter :1155000, loss:0.079117\n",
      "tinl ceat is y. Packages correctly. Principle (SRP) for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of \n",
      "\n",
      "\n",
      "iter :1155500, loss:0.077594\n",
      "arecos susus sisto make tomponether. Cohesion isto intes tarviot couceasithe onge noth aectint Basy hotedint togething ysyour poupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It\n",
      "\n",
      "\n",
      "iter :1156000, loss:0.078778\n",
      " keveduratid.ge ovit, ie tho pound woug.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveacsmans \n",
      "\n",
      "\n",
      "iter :1156500, loss:0.078752\n",
      "sid. Thepende.\n",
      "\n",
      "Then, instead of writing uny corpess mace.\n",
      "\n",
      "Thea domponents clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things and otjercof d\n",
      "\n",
      "\n",
      "iter :1157000, loss:0.077799\n",
      "penesinly that ysproge in thandes to inendare to understand and maintain if components.\n",
      "\n",
      "Ideallyod thingetowythererien thed ofsist Batise together, capuld we estopent duracke shansion thieg thand I ho\n",
      "\n",
      "\n",
      "iter :1157500, loss:0.076935\n",
      " campo eraod proup areplaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require c\n",
      "\n",
      "\n",
      "iter :1158000, loss:0.075985\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1158500, loss:0.075520\n",
      "Textsill components crmhonorpopeneas es omsos do enorkane togithentopl dig pests.\n",
      "\n",
      "Wevicints enouctedfroreatedts focuine caur in arom er iog theall oncertate to urherents.\n",
      "\n",
      "Ideally, we should aim for \n",
      "\n",
      "\n",
      "iter :1159000, loss:0.074213\n",
      "agl your and BasketRepository have in common? Nothing. Both address dupuctsy mathor. The coderatid.\n",
      "\n",
      "The roness fodetabe inges surild ro arkuvedy paly de changed or even replaced without impacting oth\n",
      "\n",
      "\n",
      "iter :1159500, loss:0.073735\n",
      "ed mometRer muclingra sige code ro undes sur the oreane suplevergrf rearecrecole com rhaw dully.g\n",
      "\n",
      "\n",
      "Bys. \n",
      "Ie bo leve ys Pfowry components clearr hagro cory of the code that serves a common purpose sta\n",
      "\n",
      "\n",
      "iter :1160000, loss:0.072759\n",
      "deront tory crane iour thingy or areffecting onessint domall components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to\n",
      "\n",
      "\n",
      "iter :1160500, loss:0.073842\n",
      ", wine Us to a madd yog.\n",
      "\n",
      "The code that changes together es yosisg. The race that do untes od wit we smarle code component componend masy Couplicher components, these components will inevitably intera\n",
      "\n",
      "\n",
      "iter :1161000, loss:0.073387\n",
      "aced without impactinglys unce ssefraced sinly and Basitorestand inveructnher romponethap chatsing publich unit tests for every pullic methons, boutewict, bounded contexts.\n",
      "\n",
      "The basic summary of the s\n",
      "\n",
      "\n",
      "iter :1161500, loss:0.076636\n",
      "t cantura intr ang ProductRepouctersing that knowledge in your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing.\n",
      "\n",
      "\n",
      "iter :1162000, loss:0.107303\n",
      "d ary hove itic! inge. Youricle necthe ithe cinnerstand and maintain if your architectural ideas map explicitly into the code. Your code should reflect Couplad commod pactstare issentidicgs th ackagew\n",
      "\n",
      "\n",
      "iter :1162500, loss:0.139022\n",
      "penes together, cary ofuncldy.\n",
      "\n",
      "The bace you n.\n",
      "\n",
      "W enog of coucline cablays of cod de cha code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a\n",
      "\n",
      "\n",
      "iter :1163000, loss:0.124910\n",
      " in ents.\n",
      "\n",
      "Ideally, we should aim for hichingr es commancterNtling ysurkady beatiou tR public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packag\n",
      "\n",
      "\n",
      "iter :1163500, loss:0.113045\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1164000, loss:0.114501\n",
      "The compoutncin your aro inould ancom of cohe to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "Th\n",
      "\n",
      "\n",
      "iter :1164500, loss:0.103187\n",
      "as cin mmamkoneweration conearective testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose,\n",
      "\n",
      "\n",
      "iter :1165000, loss:0.092798\n",
      "y.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is th\n",
      "\n",
      "\n",
      "iter :1165500, loss:0.084771\n",
      "de the ill und roupderacs of we cans components and onceryour cod comadit inly arne tame ssams con ests for every publle lesy po be capturing the to understand and maintain if your architectural ideas\n",
      "\n",
      "\n",
      "iter :1166000, loss:0.080397\n",
      "wing ldom our accerg your.\n",
      "\n",
      "Then, boug troup inonet coup ing ite prearctes that.\n",
      "\n",
      "\n",
      "Wecumponendes steasicinction ancode arn ine cant compone, and ProductRepository are highly coupled; why would not you\n",
      "\n",
      "\n",
      "iter :1166500, loss:0.075733\n",
      "e annose\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages throug theviog in witidg big yo\n",
      "\n",
      "\n",
      "iter :1167000, loss:0.074231\n",
      " pouth thous tury difly hr alc ive te fofuet houliss wot is anta is oh compondefrcomrose hevery pubgry underors wine gemting bullit to enosurcon ineas es of a specific domain/context and only provide \n",
      "\n",
      "\n",
      "iter :1167500, loss:0.072412\n",
      "t ars together, stewit impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined\n",
      "\n",
      "\n",
      "iter :1168000, loss:0.070829\n",
      " ampule taris coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnect\n",
      "\n",
      "\n",
      "iter :1168500, loss:0.069857\n",
      " cant componentari kfore can ilim or puclntext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different \n",
      "\n",
      "\n",
      "iter :1169000, loss:0.068748\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1169500, loss:0.068256\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Textho lo lepe temle arupkages that douply are is cout yfit your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that chan\n",
      "\n",
      "\n",
      "iter :1170000, loss:0.067324\n",
      "a w components.\n",
      "\n",
      "Ien stout iciog thaylwigly yous arkucturing your code as beginners framework tutorials once taurhaist corpler.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why\n",
      "\n",
      "\n",
      "iter :1170500, loss:0.066937\n",
      "ed mooneas dfurka y hode sions enorealed chines todully insy sears the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with \n",
      "\n",
      "\n",
      "iter :1171000, loss:0.066136\n",
      "de the ion es ancess of y coma is of ancom thy ucthes to crearether.\n",
      "\n",
      "Thene dime iont ecrerall arcencofict dewtrakn your issty cod inog chans ofwer bo thy inge andede concept, and I hope you have unde\n",
      "\n",
      "\n",
      "iter :1171500, loss:0.066602\n",
      "wing le rof eracsiog ghotlit ing unill ine component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principl\n",
      "\n",
      "\n",
      "iter :1172000, loss:0.065175\n",
      "e enthe gh yout pocthes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of\n",
      "\n",
      "\n",
      "iter :1172500, loss:0.065761\n",
      " kabende thit youthouBlar.\n",
      "\n",
      "Theddeadd anceconthing public interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can\n",
      "\n",
      "\n",
      "iter :1173000, loss:0.065483\n",
      "sig fofpes adr iche and lencant compon puppicilly tode temptation to make othe shain if yracs of wricleng together, careffectict doug.\n",
      "\n",
      "Coepres ever context and only pour isichithou tn we dontann and \n",
      "\n",
      "\n",
      "iter :1173500, loss:0.065163\n",
      " be rain if your are sirged svery of the code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next importa\n",
      "\n",
      "\n",
      "iter :1174000, loss:0.065103\n",
      " inew cimponents.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control fo\n",
      "\n",
      "\n",
      "iter :1174500, loss:0.064911\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1175000, loss:0.065320\n",
      "Textsinle overatid.ge overatid thing yrod callactict doupled they puckages s arr context and ProductService, ath agut if pooreacsiw ound anouctha lew will enderinpeneas essentistedy the code the inees\n",
      "\n",
      "\n",
      "iter :1175500, loss:0.065381\n",
      "agl of cup hat pour and main a aun ea lea is wiced ablin ings ges fofer inogrer ofecting other component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and lo\n",
      "\n",
      "\n",
      "iter :1176000, loss:0.066249\n",
      "ed mothor of thay your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays together. The code that\n",
      "\n",
      "\n",
      "iter :1176500, loss:0.066314\n",
      "de the ing boghectery paver inte sts ons your code alingy to lices caved defent, bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your arc\n",
      "\n",
      "\n",
      "iter :1177000, loss:0.067683\n",
      "tinly sumlothe one is ahinged or eve ibly th we nout anle te ipererkbo cof comary heagle story is that things getextsit.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common p\n",
      "\n",
      "\n",
      "iter :1177500, loss:0.066606\n",
      "e enthe will init to leac intine ses s ghot ing dom of priblasy together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will\n",
      "\n",
      "\n",
      "iter :1178000, loss:0.067573\n",
      " concept, and I ompont ing brodectSotuticizly int coun aed ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully enca\n",
      "\n",
      "\n",
      "iter :1178500, loss:0.067450\n",
      "t ars together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to \n",
      "\n",
      "\n",
      "iter :1179000, loss:0.067017\n",
      "pes compore tha nodeit covedit things gesiticled context and only provide access together.pleplet to armeraide thain if your aro cory of ancom und withy sempome ancom thy sol thyos the code that serve\n",
      "\n",
      "\n",
      "iter :1179500, loss:0.066873\n",
      " in entsitRep inory prcamr of roated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptat\n",
      "\n",
      "\n",
      "iter :1180000, loss:0.066238\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1180500, loss:0.066091\n",
      "Texth the code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is \n",
      "\n",
      "\n",
      "iter :1181000, loss:0.065407\n",
      "agl you dally hatedcof meanc ive testing\n",
      "\n",
      "Components with a single, well-defined purpose are easy to understand and much more readable. The name of such components clearly announces their purpose, and\n",
      "\n",
      "\n",
      "iter :1181500, loss:0.065345\n",
      "ed mound the hes wuricints wnouls ovedy prampther coupling Brot xanes.\n",
      "\n",
      "The code that changes together stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple\n",
      "\n",
      "\n",
      "iter :1182000, loss:0.064638\n",
      "der! The evion impuntarit in ifor achessyotsyoucomponents.\n",
      "\n",
      "When software is ous ancom dapl-deralic your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and\n",
      "\n",
      "\n",
      "iter :1182500, loss:0.065166\n",
      "tinle surlecchanges of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests for every public method of every class, writ\n",
      "\n",
      "\n",
      "iter :1183000, loss:0.063828\n",
      "e enthe wiling erotu ning the dompos nact en are com rhay difey toglethic and masit inly innt coness contsiln all y. Cohesion announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary \n",
      "\n",
      "\n",
      "iter :1183500, loss:0.064453\n",
      " ithe tha simpund oncepl, ancecessary dependencienitory tugfacentspt enterannted.\n",
      "\n",
      "ntays, yrutled ofra covectsterkited mare deat youliclesss.\n",
      "\n",
      "Itassind oorer in pome, ans ins mmuef siges stays torBect\n",
      "\n",
      "\n",
      "iter :1184000, loss:0.064238\n",
      "lit your arcunut Base tha lh context in turpll chices to che story is coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of control \n",
      "\n",
      "\n",
      "iter :1184500, loss:0.063756\n",
      "penesi- tuces th ingey sests.\n",
      "\n",
      "What your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes together stays toget\n",
      "\n",
      "\n",
      "iter :1185000, loss:0.063645\n",
      " campoyeptstans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "Wergeple (nthe de\n",
      "\n",
      "\n",
      "iter :1185500, loss:0.063115\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly erimp\n",
      "\n",
      "\n",
      "iter :1186000, loss:0.063025\n",
      "Texth wuct turithe ore tho inge, mare reat ino pompthe grogr context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. B\n",
      "\n",
      "\n",
      "iter :1186500, loss:0.062513\n",
      "agl you dally hm and it. Chec presisif boupestrer or evion im entint your to or contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so w\n",
      "\n",
      "\n",
      "iter :1187000, loss:0.062462\n",
      "ed mother of ineed marreco mameer anntcow. The arcunctand and I tull concept, and I hope your paen of your acoud couplidd ancecossyopteveracontext and only probled to evens dorepcoup iour codectsyopes\n",
      "\n",
      "\n",
      "iter :1187500, loss:0.061963\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "de the ion es aryess mfont der chiwgs to cleasiting mrans of corpess bogexts wequrplin. The result is a system that consists of cooperating but independent, bounded contexts.\n",
      "\n",
      "The basic summary of the\n",
      "\n",
      "\n",
      "iter :1188000, loss:0.062549\n",
      ", bout th oh thene componentarllinc and interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or eve\n",
      "\n",
      "\n",
      "iter :1188500, loss:0.061394\n",
      "e taylyowling maditsialla s mhing I hope drit youriced suriel- abing un to pled oupt turpcting om or interacts with other components.\n",
      "\n",
      "Idellace pode that.\n",
      "\n",
      "The code that changes together stays togethe\n",
      "\n",
      "\n",
      "iter :1189000, loss:0.062070\n",
      " kagumPings to are simain yr?\n",
      "\n",
      "Id contain ound wing the domain knowledge in working code and protecting that knowledge in your context from other contexts.\n",
      "\n",
      "What do aread one ia yings together, stays \n",
      "\n",
      "\n",
      "iter :1189500, loss:0.061998\n",
      "sid. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn corre\n",
      "\n",
      "\n",
      "iter :1190000, loss:0.061589\n",
      "penender components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of cooperat\n",
      "\n",
      "\n",
      "iter :1190500, loss:0.061573\n",
      " campoyepts gh ince. \n",
      "f med oges a mhom urky. Priquring that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the ar\n",
      "\n",
      "\n",
      "iter :1191000, loss:0.061167\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1191500, loss:0.061127\n",
      "ge.\n",
      "\n",
      "The pough effecthe dompow civer context wep if y access bounded contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and \n",
      "\n",
      "\n",
      "iter :1192000, loss:0.060727\n",
      "avinde thot canner covedy.\n",
      "\n",
      "Then, instead objects.\n",
      "\n",
      "When stoty.\n",
      "\n",
      "Ideasier to understand and maintain if your architectural ideas Prconcecturacts whe sthe the demes components.\n",
      "\n",
      "Ideally, we should rig \n",
      "\n",
      "\n",
      "iter :1192500, loss:0.060722\n",
      "ed mathe one tem taylsy.\n",
      "\n",
      "The ches one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevita\n",
      "\n",
      "\n",
      "iter :1193000, loss:0.060311\n",
      "de the ill ing blowerither, deatrowiturt Thay.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deveap\n",
      "\n",
      "\n",
      "iter :1193500, loss:0.060937\n",
      "witlyog the code your.\n",
      "\n",
      "Thevects are they the acot effectively draw and enforce boundaries during deveaple conce taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and p\n",
      "\n",
      "\n",
      "iter :1194000, loss:0.059851\n",
      "e toputtreat tests.\n",
      "\n",
      "\n",
      "haclinges togedoreanemt, and ducom thy s une esither contexts.\n",
      "\n",
      "The bout and kestrothe he orpergro cone nverrobunt er to understand and maintain if your architectural ideas map e\n",
      "\n",
      "\n",
      "iter :1194500, loss:0.060560\n",
      " kableveas of control for low coupling.\n",
      "\n",
      "Wher contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why group them together?\n",
      "Product, P\n",
      "\n",
      "\n",
      "iter :1195000, loss:0.060501\n",
      "n thances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnecte\n",
      "\n",
      "\n",
      "iter :1195500, loss:0.060152\n",
      "penent'n suchices to cleasiond merpele is ans or eves. Itexple can beuchinges together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependen\n",
      "\n",
      "\n",
      "iter :1196000, loss:0.060142\n",
      " campoyeptstans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist\n",
      "\n",
      "\n",
      "iter :1196500, loss:0.059791\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1197000, loss:0.059757\n",
      "Text imporplit. Pade that will end up in a musios to clearly ofor achessyllrour paeninct enur to orke esha yould not you group them? Cohesion - the code that changes together, stays together, carefull\n",
      "\n",
      "\n",
      "iter :1197500, loss:0.059379\n",
      "asiny steraccend de on krew your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different proble\n",
      "\n",
      "\n",
      "iter :1198000, loss:0.059390\n",
      "ed mound meveracts with ovet, youthou nnes esur to or iner aru in you forp centoully. gh nor chige ta s acsessesse le en are and thinges thrwiclesien ant codo Promucin teat yod pucinge won efer of re \n",
      "\n",
      "\n",
      "iter :1198500, loss:0.058988\n",
      "de the ill indercobly code plit your arconticlen, ios sha deasion to mace if you corr co ine fout will end hand components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single\n",
      "\n",
      "\n",
      "iter :1199000, loss:0.059625\n",
      ", bhat composed interfornecont yom mama derple conterinit tests for every public method of every class, write unit tests focusing on the component's public interface, covering every behaviour of the u\n",
      "\n",
      "\n",
      "iter :1199500, loss:0.058545\n",
      "e tha erable comconles stans torBtat thinteents.\n",
      "\n",
      "When software is des wectext of or im acrechavery purkngeunt il or mect, are urpy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to u\n",
      "\n",
      "\n",
      "iter :1200000, loss:0.059266\n",
      " kagecting your code arn pra nomponentanl or underpend your accepletes mare re four code and in anterais a cont code and in antext ificlery hmacte smacler components, these components will inevitably \n",
      "\n",
      "\n",
      "iter :1200500, loss:0.059184\n",
      "s er Cour access maprectinntsew.\n",
      "Thes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in\n",
      "\n",
      "\n",
      "iter :1201000, loss:0.058873\n",
      "penent'n roore concept, yonthy cone podelat codeithy ithe Single compone foug thane none des wecrecendereras enounctaring tectsyoneweratinnt your to licen ef ompepknew.y ohine daceand y hope you have \n",
      "\n",
      "\n",
      "iter :1201500, loss:0.058866\n",
      " in entsitRwiting ever context arit youp cour poneatrerlertind y. Ppomuracsessent fofued dh thetrore tha in wept mances tod code acle bour context from contamination and overreaching from other contex\n",
      "\n",
      "\n",
      "iter :1202000, loss:0.058529\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1202500, loss:0.058520\n",
      "C. Pung houth onceas map explicitn cour pouplif ys tur, thaise punt for row yourot oupl-dare inserassestexl-define conced., your archices th wectuxt and on common purpose stays together. Cohesion into\n",
      "\n",
      "\n",
      "iter :1203000, loss:0.058132\n",
      "aving objted rontext and onondery acla encturing your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working code and protecting that k\n",
      "\n",
      "\n",
      "iter :1203500, loss:0.058155\n",
      "wicthey togethe will ine tay sectedfot correctly. Packisis on om ofring foulcound anc sa?ka duct, youtit inou dout arpullin. Yofricing your coduct and mace ceand Iver context and only provide access t\n",
      "\n",
      "\n",
      "iter :1204000, loss:0.057754\n",
      "rectRe th t contexts.\n",
      "\n",
      "Wher yoge that chageple ss womain knowledge in wecting that knowledge isseration annted.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependen\n",
      "\n",
      "\n",
      "iter :1204500, loss:0.058398\n",
      "ced and ongef fundergerilly into and Prod cecthes togetoectha le ark? to understand and yout arlicle eveo ery of the code that siog unge ithergrol ther interact noterysitntogre focectedully we insy. \n",
      "\n",
      "\n",
      "\n",
      "iter :1205000, loss:0.244274\n",
      "e tagu ithesion. Usulk frepontes.\n",
      "\n",
      "Whe abat in mmating your code the douthaide rayse coveding fowe that will yin ha le suculinit thit components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coup\n",
      "\n",
      "\n",
      "iter :1205500, loss:1.312643\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ro enains bounderp mpund anc conorectares and sthe that es to khoule raykages corresiqte ba in entsithin. Ba yohese- tued poubine defenestably the Single Responsithy.\n",
      "\n",
      "Low coupled. Pade the code to u\n",
      "\n",
      "\n",
      "iter :1206000, loss:1.449011\n",
      "s an es siflit's wer arres chige teyr poned intercontext from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address \n",
      "\n",
      "\n",
      "iter :1206500, loss:1.276215\n",
      "ationd maens mapk os component can be changed or even replaced without impacting other component drpendepter, puply intectsion the sis surr cimpund and overreaching from other components.\n",
      "\n",
      "Ideally, we\n",
      "\n",
      "\n",
      "iter :1207000, loss:0.905507\n",
      " coull ac!ogethin. Bo rompouther, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need t\n",
      "\n",
      "\n",
      "iter :1207500, loss:0.619255\n",
      "or even replaced without impacting other component depends on on erfectura that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases tur\n",
      "\n",
      "\n",
      "iter :1208000, loss:0.445731\n",
      "Textsiod oul, wing text, anly th arcomais aky tessind oup yowy ded component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Sing b\n",
      "\n",
      "\n",
      "iter :1208500, loss:0.326455\n",
      "agus mount bount des component component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesiondacti\n",
      "\n",
      "It as ro are compour ara component you derenasisis surl-dyowy hi\n",
      "\n",
      "\n",
      "iter :1209000, loss:0.253732\n",
      "ed mothor lyogreatrowittyess ans and in anterall ino pear fowedt, and yontu\n",
      "g povertitr ary pendeptsien suclasse, ponone haverucontexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier \n",
      "\n",
      "\n",
      "iter :1209500, loss:0.199252\n",
      "ss way thep encercones oug cang your aro make everyod objects.\n",
      "\n",
      "When sssururint contexts.\n",
      "\n",
      "What do Produ sioge concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing\n",
      "\n",
      "\n",
      "iter :1210000, loss:0.168498\n",
      "wither?\n",
      "Prorresu nour to und component. Therrerpesioge concept, and I hope ysur cungs tositis anctitr acy.\n",
      "\n",
      "Coxpling Bayrerpued anceconthing public! That is why codebases turn into a mass of interconn\n",
      "\n",
      "\n",
      "iter :1210500, loss:0.151111\n",
      "e every pund ba urganize your componencinsy.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is \n",
      "\n",
      "\n",
      "iter :1211000, loss:0.134340\n",
      " roupling means fedeptsinly to inted.\n",
      "\n",
      "The to y.\n",
      "\n",
      "Cemssiont ic ing.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacti\n",
      "\n",
      "\n",
      "iter :1211500, loss:0.118966\n",
      "s an is your architectural ideas map explicitly into the code. Your code should reflect the archit cour pling the cofucthous and Pacer thic interfoces and in that things get much easier to understand \n",
      "\n",
      "\n",
      "iter :1212000, loss:0.156673\n",
      "penes thes that componentablyk, youtinlit ingallacts wit your coductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays to\n",
      "\n",
      "\n",
      "iter :1212500, loss:0.143809\n",
      " cemainess, lo learn correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should anc consain maintain if your context from contamination and overre\n",
      "\n",
      "\n",
      "iter :1213000, loss:0.121636\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1213500, loss:0.106783\n",
      "The inner to les correctly. Packages should contain all classes of a specific domain/context and only provide access to other packages through a unique interface.\n",
      "\n",
      "Then, instead of writing unit tests \n",
      "\n",
      "\n",
      "iter :1214000, loss:0.095811\n",
      "asiny accerg ishe os w. The neshaid sucis th aro ceves Yosucine dampomtncont bos sacy poot im ontsies - the code arcumpoy.\n",
      "\n",
      "The bave sts of er inverystoul chic and I hope ys evey th orethw. rhat ssing\n",
      "\n",
      "\n",
      "iter :1214500, loss:0.088588\n",
      "ed momet, yodeat youliclessing The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thi\n",
      "\n",
      "\n",
      "iter :1215000, loss:0.082895\n",
      "de the ither aflith yiflly urf compther ofed contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries durin\n",
      "\n",
      "\n",
      "iter :1215500, loss:0.079775\n",
      "witlycohetos stays components.\n",
      "\n",
      "When software is witinged ontext frating your code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge in working co\n",
      "\n",
      "\n",
      "iter :1216000, loss:0.075982\n",
      "e evur contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is onting yo resist thint bout.\n",
      "\n",
      "\n",
      "iter :1216500, loss:0.074587\n",
      "t cant nt an thod of componend mactucin entsit Tf contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address dofunden, wilg you ha ghe code thy ur code arvery pull\n",
      "\n",
      "\n",
      "iter :1217000, loss:0.073005\n",
      "tige la ses stacsiog oncom dewing oghe ssilly beat youlding bully ontexthin your aed contexts.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand andem thes that cowea entext\n",
      "\n",
      "\n",
      "iter :1217500, loss:0.071398\n",
      "pliteddearatect, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion. Use poredy packaut mode thy ur yode and it pour thioge hemath verrerilg isit componen\n",
      "\n",
      "\n",
      "iter :1218000, loss:0.070260\n",
      " coucha le evio chat thing yly boundercoppesion. Use well-defined interfaces and inversiog from comyopriou chould contain all classes of a specific domain/context and only provide access to other pack\n",
      "\n",
      "\n",
      "iter :1218500, loss:0.068898\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When sof to stow covilc contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why\n",
      "\n",
      "\n",
      "iter :1219000, loss:0.068113\n",
      "Th are and im onito yo? che uncery ur if ariting mor wieg th aco precing iteat triale reatly urlecomrore amurkagee shaind code ury aculithe defonte boundar encod ouness of coopers foflet. Pra into Pra\n",
      "\n",
      "\n",
      "iter :1219500, loss:0.067012\n",
      "asiny accerg ines to clathais to ams sve simroc compestode is tncwind otRes and counes enilly.\n",
      "\n",
      "The code archings tod laylice, correctass together, capul; !ohesinged on the component's public interfac\n",
      "\n",
      "\n",
      "iter :1220000, loss:0.066231\n",
      "ed mometRes tode cempo ehy components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that co\n",
      "\n",
      "\n",
      "iter :1220500, loss:0.065282\n",
      "dero that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize y\n",
      "\n",
      "\n",
      "iter :1221000, loss:0.065291\n",
      "wit control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other component erpor hracing to li\n",
      "\n",
      "\n",
      "iter :1221500, loss:0.063769\n",
      "e every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Componen. The -ofeate ramu should aim for how of rould be capturing the domain know tosutis d pontain all classess maka surc\n",
      "\n",
      "\n",
      "iter :1222000, loss:0.063916\n",
      " pouth and your access level, the fewer chances to create unnecessary dependencies that will er.\n",
      "\n",
      "The basic sumsterface, bo yode thy urhe compore, and ProductRepository are highly coupled; why would n\n",
      "\n",
      "\n",
      "iter :1222500, loss:0.063405\n",
      "n thances to crealate code inte, mapesion. Use wall or iste, and componen to are code that serves rofelpents founecose con efully thow thit. Checkout my article about effective testing\n",
      "\n",
      "Components wit\n",
      "\n",
      "\n",
      "iter :1223000, loss:0.062649\n",
      "plitedrorcencowe ion centext ann context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different indy t\n",
      "\n",
      "\n",
      "iter :1223500, loss:0.062225\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " couch components clearlace.\n",
      "\n",
      "Then, ins orper inot erpore, and it youromponed intecturaes forpoucin ans together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to c\n",
      "\n",
      "\n",
      "iter :1224000, loss:0.061496\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1224500, loss:0.061072\n",
      "The da guble should aim for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component c\n",
      "\n",
      "\n",
      "iter :1225000, loss:0.060431\n",
      "as aine andout con efully encens ourot cinged on the Ros components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. \n",
      "\n",
      "\n",
      "iter :1225500, loss:0.060002\n",
      "ery beharerfices ans yode, and ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays together, carefully encapsulated\n",
      "\n",
      "\n",
      "iter :1226000, loss:0.059420\n",
      "de thing public! That is why codedasit. The smaks to iner th towes ouplit weples components, these components will inevitably interact with one another, and it will require clearly defined boundaries \n",
      "\n",
      "\n",
      "iter :1226500, loss:0.059676\n",
      "yl, anctests frill coure cofreats.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is ont aky to\n",
      "\n",
      "\n",
      "iter :1227000, loss:0.058463\n",
      "e evires taritith o ofkan.\n",
      "\n",
      "\n",
      "Lowedings ots arcemptcted purponent dart che hous wit de coopes eday and int to enea svers fode the torether. Coupd th woupled changed orpendy and lefecterIthy thing youpd\n",
      "\n",
      "\n",
      "iter :1227500, loss:0.058876\n",
      " iovericts are code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn\n",
      "\n",
      "\n",
      "iter :1228000, loss:0.058585\n",
      "sig. Boug to un such agcomponend mos the componendan? Notewitictsy.\n",
      "\n",
      "Whem out how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low co\n",
      "\n",
      "\n",
      "iter :1228500, loss:0.058075\n",
      "plitedror changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decon covedy publly erory are highly coupled; why would not you group them? Cohesion - the code that changes to\n",
      "\n",
      "\n",
      "iter :1229000, loss:0.057861\n",
      " invedy pubing decon coull ain knot mallacsiog frod code and it code and pouply ublic! That code as beginners framework tutorials once taught you.\n",
      "\n",
      "By now, you should be capturing the domain knowledge\n",
      "\n",
      "\n",
      "iter :1229500, loss:0.057370\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components wililly imperkandeplated.\n",
      "\n",
      "The more restricted your access level, the fewer \n",
      "\n",
      "\n",
      "iter :1230000, loss:0.057103\n",
      "The yous wind iage is angessents focuctndeptient druct is ans low -dely and lyodend arable wing y umpends to lea sterfecting\n",
      "\n",
      "Comedilic! That is why codebases turn into a mass of interconnected object\n",
      "\n",
      "\n",
      "iter :1230500, loss:0.056693\n",
      "agl oncept coure that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential t\n",
      "\n",
      "\n",
      "iter :1231000, loss:0.056425\n",
      "wdy.\n",
      "\n",
      "Cohe smaclestowither stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next i\n",
      "\n",
      "\n",
      "iter :1231500, loss:0.056045\n",
      "ss corplceapr.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code should reflect the architec\n",
      "\n",
      "\n",
      "iter :1232000, loss:0.056456\n",
      "yllrale erter ibig things geteryon ha e togectestonla suw is with u no ene. Pachit impamitorees forerconnectiont acouplin. Use well-defined into smallw y. Coghmacth suctibly bunglit. Boveracos shes to\n",
      "\n",
      "\n",
      "iter :1232500, loss:0.055415\n",
      "e youplinly and othe ofererfeces ass merchit codreplatect, wuyint components. It means one component can be changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed in\n",
      "\n",
      "\n",
      "iter :1233000, loss:0.055984\n",
      " concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one component depends on or interacts with other components\n",
      "\n",
      "\n",
      "iter :1233500, loss:0.055835\n",
      "sid Arpent you haver componentars together todr pod of cavedy and leve wing y deat yould ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, \n",
      "\n",
      "\n",
      "iter :1234000, loss:0.055472\n",
      "plitrer, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the code. Your code sho\n",
      "\n",
      "\n",
      "iter :1234500, loss:0.055386\n",
      " coucha code the pot im od thealy common thy underat yould not you nacy how coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversion of co\n",
      "\n",
      "\n",
      "iter :1235000, loss:0.055037\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1235500, loss:0.054895\n",
      "The besis cound orcode and in antextsinle sveld ancomyotRechaply.\n",
      "\n",
      "Low coull undeet compot iavery pave componed intecowithe demple concept tunt and maintain if the code that changes together, stays to\n",
      "\n",
      "\n",
      "iter :1236000, loss:0.054615\n",
      "asiny dep accerer er? ingexth that componed inticessy to they the code that changes together sory po nay.\n",
      "\n",
      "Low yupl components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Si\n",
      "\n",
      "\n",
      "iter :1236500, loss:0.054483\n",
      "ed mound the susions hore, and ProductRepository are highly coupled; why your pouronespendroun archice that will ine hom?rcos orams to int evisit. Checkout my article about effective testing\n",
      "\n",
      "Componen\n",
      "\n",
      "\n",
      "iter :1237000, loss:0.054222\n",
      "de hrigh you nhepllroull conterericly sualasys boge, and surhes cuagemanig bou homkunt malaisitha le everka youpling othes, svernous and Paces and ino pompint yopretinnersio yode aon thaw onces th we \n",
      "\n",
      "\n",
      "iter :1237500, loss:0.054776\n",
      "cle dofledacti\n",
      "\n",
      "The cings entare your.\n",
      "\n",
      "Coupling lsyod pain ald entspung thouleted saring dout thive tontext and inot to understand and maintain if your architectural ideas map explicitly into the cod\n",
      "\n",
      "\n",
      "iter :1238000, loss:0.053863\n",
      "e your are arcunctand and maintain if we can effectively draw and enforce boundaries during deve is ont deponte.\n",
      "\n",
      "Tve y umpones sus to learn component depends on or interacts with other components.\n",
      "\n",
      "I\n",
      "\n",
      "\n",
      "iter :1238500, loss:0.054582\n",
      " pouth anogether, cant? Nos to on common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn\n",
      "\n",
      "\n",
      "iter :1239000, loss:0.054598\n",
      "nin ald y ofla inverystoge in to spour thew of interasss baly hay iod ouplet components, these components will inevitably interact with one another, and it will require clearly defined boundaries not \n",
      "\n",
      "\n",
      "iter :1239500, loss:0.054365\n",
      "plitedrorcencoweat yod prompot cfile that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected object\n",
      "\n",
      "\n",
      "iter :1240000, loss:0.054444\n",
      " coucha componj cole conce taught you.\n",
      "\n",
      "By now, you deas we thally need to lefer, and into ans ctogether?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you group the\n",
      "\n",
      "\n",
      "iter :1240500, loss:0.054221\n",
      "or even replimed sthare ra laced cfilg you nee strand I ho bo yo? Product, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes toge\n",
      "\n",
      "\n",
      "iter :1241000, loss:0.054235\n",
      "The your the component's gevig th to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is th\n",
      "\n",
      "\n",
      "iter :1241500, loss:0.054068\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a w control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can be changed or even replaced without impacting other component depends on or inter\n",
      "\n",
      "\n",
      "iter :1242000, loss:0.054065\n",
      "ed mothore. ges ro enorucillict wo stsyog sventict publinle (SRP) for high cohesion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections a\n",
      "\n",
      "\n",
      "iter :1242500, loss:0.053886\n",
      "dectRpubog un to maced macthe co beverves togeverit your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "The code that changes toge\n",
      "\n",
      "\n",
      "iter :1243000, loss:0.054558\n",
      "cle announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into the\n",
      "\n",
      "\n",
      "iter :1243500, loss:0.053676\n",
      "entico your code as beginnerster, and yo? lows on commanc shanges ances th arcould componentarsit It all con couct as once th unces th we rif yowet wicles correcthyos sher the Sisilly th wr tawe that \n",
      "\n",
      "\n",
      "iter :1244000, loss:0.054458\n",
      " kasunde invery bnom thad contRes wige that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make everything public! That is why codebases turn into a mass of interconnected obje\n",
      "\n",
      "\n",
      "iter :1244500, loss:0.054502\n",
      "sid.\n",
      "\n",
      "The code the kny.\n",
      "\n",
      "The pople is enteract pund and yfor, yould a auc pequed coraes simpls concecturacts with orporerfices dupl- shes ro extes tarntents fearly chathe components.\n",
      "\n",
      "When software is\n",
      "\n",
      "\n",
      "iter :1245000, loss:0.054278\n",
      "pes your code acsing y houlictes masit things to arurech mapy he code that serves a common rabisisin context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and Bas\n",
      "\n",
      "\n",
      "iter :1245500, loss:0.054367\n",
      " comply code con efully imlevint onet.\n",
      "\n",
      "The empontiog overrebuging ulitly contadd and mura layrext wit your co urkandey toodecthe nounit thing public! That is why codebases turn into a mass of interco\n",
      "\n",
      "\n",
      "iter :1246000, loss:0.054145\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1246500, loss:0.054158\n",
      "Textsille te fecrive tohe bout im ofpo istenting ysur ake rherythy things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is ont depentemt, wno\n",
      "\n",
      "\n",
      "iter :1247000, loss:0.053990\n",
      "ave urctions onon to licem ans dore, and more readd onf ycomponent. Theryorela, yourain mact nohethereriticly pabict bou crepter, ishar into ans once. Yowing onj codulit do arkassey too ende win ha le\n",
      "\n",
      "\n",
      "iter :1247500, loss:0.053991\n",
      "ed mound the ghim. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need \n",
      "\n",
      "\n",
      "iter :1248000, loss:0.053801\n",
      "dectsinit io inountinu tavedy pave sif component draylicents fee component's wompontain ouc chaneratint anctinntedr ctewictmrall gentsie th uner ac undectespons mapk ofuratid.gThe basic summary of the\n",
      "\n",
      "\n",
      "iter :1248500, loss:0.054526\n",
      "ticter, dratedtsefreat thing you decorencessyog on e that.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if the code that changes together, stays together, \n",
      "\n",
      "\n",
      "iter :1249000, loss:0.053604\n",
      "e youndarit ifly arly chans to amuncences simple concept, and I hope you have understood it already.\n",
      "\n",
      "Coupling is the next important thing you need to learn correctly. It is about how much one compone\n",
      "\n",
      "\n",
      "iter :1249500, loss:0.054408\n",
      " rouchanges to crees, y. Cohedinges together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a\n",
      "\n",
      "\n",
      "iter :1250000, loss:0.054446\n",
      "sid. ke of cour pung bouc hew will ine ianles together?\n",
      "lI muring the dode and wh oundencobly we simet, yourha inow cuns is your context from contamination and overreaching from other contexts.\n",
      "\n",
      "What \n",
      "\n",
      "\n",
      "iter :1250500, loss:0.054213\n",
      "plitedrore com offrcomrone tor thawitile leark tamrectRestot yourdacsiog othes, sveriot your arcom daal components. It means one component can be changed or even replaced without impacting other compo\n",
      "\n",
      "\n",
      "iter :1251000, loss:0.054287\n",
      " canl clansiog fecom thy urkag.\n",
      "\n",
      "Lhy tinly momeratitoretsifill- to Cothe that your architectural ideas map explicitly into the code. Your code should reflect the architecture diagrams that you draw.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :1251500, loss:0.054053\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1252000, loss:0.054048\n",
      "The yous wind ithing public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of a specific do\n",
      "\n",
      "\n",
      "iter :1252500, loss:0.053853\n",
      "avinge thot cfungrentsieg th ackasion. Use well-defined interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one component can b\n",
      "\n",
      "\n",
      "iter :1253000, loss:0.053832\n",
      "ed mothore. ges racle, ath components oncef ory.\n",
      "\n",
      "Coupling lsyou haver components clearict beves, y anga u sts ons should aonects andes to are codg to er yowe shey together, carefully encapsulated.\n",
      "\n",
      "T\n",
      "\n",
      "\n",
      "iter :1253500, loss:0.053602\n",
      "dectsinis to learly and intor in ams of yowither stays together. The code that serves a common purpose stays together. Cohesion is a pretty simple concept, and I hope you have understood it already.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "iter :1254000, loss:0.054327\n",
      "yr, and unnts to unthe und purplduw components.\n",
      "\n",
      "Ideall of mmakntsil you ne pain if ymare iconceplars together, caref of code that ino pomposithesstond and mact conteralic! ro she arnes together?\n",
      "Prod\n",
      "\n",
      "\n",
      "iter :1254500, loss:0.053349\n",
      "e youply ine taml-dalingf your architecturacts wecuncess ass ady thoul ingerur bound with uitther components.\n",
      "\n",
      "Ideally, we should aim pagu it your acouc ia lewe is ents all componed interfaces and inv\n",
      "\n",
      "\n",
      "iter :1255000, loss:0.054123\n",
      " kagecrictly ur changed or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it wi\n",
      "\n",
      "\n",
      "iter :1255500, loss:0.054109\n",
      "n th ach context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both addrersspes components.\n",
      "\n",
      "Ideally, we should aim \n",
      "\n",
      "\n",
      "iter :1256000, loss:0.053840\n",
      "pes quedy what thiog thent sas your po re (s aved fewe is ant ithy tontectss, wode es anteraine bas inges to Prodectsit.\n",
      "\n",
      "Theng or uny. The namp contexts to lea component component depends on or inter\n",
      "\n",
      "\n",
      "iter :1256500, loss:0.053854\n",
      " campoyeptstans together, carefkout re are code to understand and much more readable. The name of such components clearly announces their purpose, and such a unit do just that.\n",
      "\n",
      "The basic summary of t\n",
      "\n",
      "\n",
      "iter :1257000, loss:0.053594\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1257500, loss:0.053533\n",
      "The yous wind ithing public! Thay ithw. The result is oh ians once thot coun ke ramk he the cempon mannes to clerke youl ael context from contamination and overreaching from other contexts.\n",
      "\n",
      "What do P\n",
      "\n",
      "\n",
      "iter :1258000, loss:0.053302\n",
      "agl of o arcunctigen stotaint if arntays fouplery pacing mamyonent correctly. It is about how much one component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesio\n",
      "\n",
      "\n",
      "iter :1258500, loss:0.053234\n",
      "ed mothoremtout will encendedtonle endentict ente che innec argess maprerall isit ta ente, workes snans on weane component depends on or interacts with other components.\n",
      "\n",
      "Ideally, we should aim for hi\n",
      "\n",
      "\n",
      "iter :1259000, loss:0.052967\n",
      "de hrigh yound puplid; why group them together?\n",
      "Product, ProductService, and ProductRepository are highly coupled; why would not you group them? Cohesion - the code that changes together, stays togeth\n",
      "\n",
      "\n",
      "iter :1259500, loss:0.053665\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wing ddiclere thy acsestes taar components.\n",
      "\n",
      "Ideall once tout hecessy.\n",
      "\n",
      "The che boundaries during devicit do them together?\n",
      "Pro inody and other contexts.\n",
      "\n",
      "What components.\n",
      "\n",
      "Ideally, we should aim for \n",
      "\n",
      "\n",
      "iter :1260000, loss:0.052648\n",
      "e bour component's mepresitn youlicles map explicitly into the code. Yowicinc winit domactents wot your to underster, ableale bour acoup thaw dof your he bound rowe sista make to cray co be capturing \n",
      "\n",
      "\n",
      "iter :1260500, loss:0.053385\n",
      " pouth ano cleasing that knowledge in your context frit yowe componed interfaces and inversion of control for low coupling.\n",
      "\n",
      "Low coupling means fewer interconnections across components. It means one c\n",
      "\n",
      "\n",
      "iter :1261000, loss:0.053323\n",
      "sig foupling ote componenderain youthinly oncensists or fow ba nor highly packa en erfeccing that.\n",
      "\n",
      "CTer context and on or could be capresion. Use well-defined interfaces and inversion of control for \n",
      "\n",
      "\n",
      "iter :1261500, loss:0.053035\n",
      "plitedotion al teint y. Produ access leqrer conner one hem nge weth cif your architectural idichingry ontext fry conseryriturcer of every public method of every class, write unit tests focusing on the\n",
      "\n",
      "\n",
      "iter :1262000, loss:0.053000\n",
      " campo enkad is to make everything public! That is why codebases turn into a mass of interconnected objects.\n",
      "\n",
      "It's essential to organize your packages correctly. Packages should contain all classes of\n",
      "\n",
      "\n",
      "iter :1262500, loss:0.052734\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1263000, loss:0.052631\n",
      "The yous wind iaglated.\n",
      "\n",
      "The more restricted your access level, the fewer chances to create unnecessary dependencies that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the temptation to make ev\n",
      "\n",
      "\n",
      "iter :1263500, loss:0.052390\n",
      "agl of o arcunctigl-defarce podeitesting\n",
      "\n",
      "Componenasis erelly.\n",
      "\n",
      "The basic summary of the story is that things get much easier to understand and maintain if your architectural ideas map explicitly into\n",
      "\n",
      "\n",
      "iter :1264000, loss:0.052290\n",
      "ed mound the ghim. The code to to rom Pach uthy romain know tos re smay toge and in ant mut inly oreat draylithings to ate cove and ro that will end up in a big ball of mud.\n",
      "\n",
      "We need to resist the tem\n",
      "\n",
      "\n",
      "iter :1264500, loss:0.052014\n",
      "ss withoup thowe smylconsersint code archings accend be capturing the domain knowledge in working code and protecting that knowledge in your context from contamination and overreaching from other cont\n",
      "\n",
      "\n",
      "iter :1265000, loss:0.052694\n",
      "till kout ro teatisis toflicents beve ather contexts.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in comstsint an y are thould contain all y. Pund interfaces and inversion of control for low \n",
      "\n",
      "\n",
      "iter :1265500, loss:0.051665\n",
      "e your and ProductRepository are hrar. The code. Your code should rofury urict nes ancou haver components onces to kroupline demarcos componen ssams, snalle.\n",
      "\n",
      "We ne ms the ro unkeviog fo ever to laced\n",
      "\n",
      "\n",
      "iter :1266000, loss:0.052382\n",
      " inveructs with a de thou nhar es components.\n",
      "\n",
      "Ideall of mmaclungr ou nhap exenfrurkcuches witigh ustess, prame he it yo? ding is turpote, and bou de ould context from contamination and overreaching f\n",
      "\n",
      "\n",
      "iter :1266500, loss:0.052297\n",
      "sig fofievery bnhy innt, whouct, ProductService, and ProductRepository are his with che bour codtig pofunderering ont xthy bould foundercably bnom thy sess code should contain all classes of a specifi\n",
      "\n",
      "\n",
      "iter :1267000, loss:0.052012\n",
      "plitedrore com thy unu h aen The component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Components with a single, well-defined purpose are eas\n",
      "\n",
      "\n",
      "iter :1267500, loss:0.051952\n",
      " simpontedyrallew components.\n",
      "\n",
      "Ideally, weptr romponething yrore hche toos the component's public interface, covering every behaviour of the unit. Checkout my article about effective testing\n",
      "\n",
      "Componen\n",
      "\n",
      "\n",
      "iter :1268000, loss:0.051699\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1268500, loss:0.051576\n",
      "C. Punind leate uncomain if y iout youpine is tatint yo ot correblamrexp ext arr cohesion. Use well-defined interfaces and inversion of controlr ace ssadramponent our isichite, an and I hope cod is al\n",
      "\n",
      "\n",
      "iter :1269000, loss:0.051346\n",
      "a tu and Bas. bosstain mmog the code that changes together, stays together, carefully encapsulated.\n",
      "\n",
      "The more restrige couc ingitles mare te focected cound mampone cha sing Promuchandes oncess fucour \n",
      "\n",
      "\n",
      "iter :1269500, loss:0.051231\n",
      "ed mation ibte components, these components will inevitably interact with one another, and it will require clearly defined boundaries not to leak the domain. The result is a system that consists of co\n",
      "\n",
      "\n",
      "iter :1270000, loss:0.050966\n",
      "ss wut ithe domarcontext from togetes ancess is the cemponed pontsilg weys rull-defin th accom tha d bansext we rofunde, and ProductRepository are highly coupled; why would not you group them? Cohesio\n",
      "\n",
      "\n",
      "iter :1270500, loss:0.051640\n",
      "cramponendererasies llvill ing und coup controbly thaple ipent's public interface, covering every behaviour of the unu. The banncess mare reat inversion of control for low coupling.\n",
      "\n",
      "Low coupling mean\n",
      "\n",
      "\n",
      "iter :1271000, loss:0.050618\n",
      "aness, mositnos together, stays together, carefully encapsulare to incee ory as ancons.\n",
      "\n",
      "What do ProductRepository and BasketRepository have in common? Nothing. Both address different problems, so why\n",
      "\n",
      "\n",
      "iter :1271500, loss:0.051329\n",
      " interacts with other components.\n",
      "\n",
      "Ideally, we should aim for high cohesion and low coupling. Apply the Single Responsibility Principle (SRP) for high cohesion. Use well-defined interfaces and inversi\n",
      "\n",
      "\n",
      "iter :1272000, loss:0.051238\n",
      "sig foupling ldomponntecting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defined bou\n",
      "\n",
      "\n",
      "iter :1272500, loss:0.050967\n",
      "pes your code acle one bavedint\n",
      "\n",
      "\n",
      "\n",
      "Low comcout ifhents.\n",
      "\n",
      "Ideally, we story is that things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is on\n",
      "\n",
      "\n",
      "iter :1273000, loss:0.050902\n",
      " comply.\n",
      "\n",
      "Coupling isitull-deperreinne tsithe domarly announces the reat things get much easier to understand and maintain if we can effectively draw and enforce boundaries during deve is onteraine Th\n",
      "\n",
      "\n",
      "iter :1273500, loss:0.050665\n",
      "or even replaced without impacting other components.\n",
      "\n",
      "When software is decomposed into smaller components, these components will inevitably interact with one another, and it will require clearly defin\n",
      "\n",
      "\n",
      "iter :1274000, loss:0.050538\n"
     ]
    }
   ],
   "source": [
    "seq_length = 25\n",
    "data_reader = DataReader(\"texts/input.txt\", seq_length)\n",
    "rnn = RNN(hidden_size=100, vocab_size=data_reader.vocab_size,seq_length=seq_length,learning_rate=1e-1)\n",
    "rnn.train(data_reader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'geth w alys evilit madorkevy houpling. Apply the Sing'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rnn.predict(data_reader, 'get', 50)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}