Saran dalam merancang aplikasi web dengan masa hidup 40+ tahun

Skenario

Saat ini, saya terpisah dari proyek perawatan kesehatan yang persyaratan utamanya adalah untuk menangkap data dengan atribut yang tidak diketahui menggunakan formulir yang dibuat pengguna oleh penyedia layanan kesehatan. Persyaratan kedua adalah integritas data adalah kunci dan aplikasi akan digunakan selama 40+ tahun. Kami saat ini sedang memigrasi data klien dari 40 tahun terakhir dari berbagai sumber (Kertas, Excel, Access, dll ...) ke database. Persyaratan di masa depan adalah:

• Manajemen alur kerja formulir
• Jadwalkan pengelolaan formulir
• Keamanan / Manajemen berbasis peran
• Mesin pelaporan
• Dukungan Mobile / Tablet

Situasi

Hanya dalam 6 bulan, arsitek / programmer senior saat ini (telah dikontrak) telah mengambil pendekatan "cepat" dan telah merancang sistem yang buruk. Basis data tidak dinormalisasi, kodenya digabungkan, tingkatan tidak memiliki tujuan khusus dan data mulai hilang karena ia telah merancang beberapa kacang untuk melakukan "menghapus" pada basis data. Basis kode sangat membengkak dan ada pekerjaan hanya untuk menyinkronkan data karena database tidak dinormalisasi. Pendekatannya adalah mengandalkan pekerjaan cadangan untuk memulihkan data yang hilang dan tampaknya tidak percaya pada re-factoring.

Setelah mempresentasikan temuan saya kepada PM, arsitek akan dipindahkan ketika kontraknya berakhir. Saya telah diberi tugas untuk merancang ulang aplikasi ini. Tim saya terdiri dari saya dan satu programmer junior. Kami tidak memiliki sumber daya lain. Kami telah diberikan pembekuan persyaratan 6 bulan di mana kami dapat fokus membangun kembali sistem ini.

Saya menyarankan menggunakan sistem CMS seperti Drupal, tetapi untuk alasan kebijakan di organisasi klien, sistem harus dibangun dari awal.

Ini adalah pertama kalinya saya akan merancang sistem dengan umur lebih dari 40+. Saya hanya bekerja pada proyek dengan rentang hidup 3-5 tahun, jadi situasi ini sangat baru, namun mengasyikkan.

Pertanyaan

• Pertimbangan desain apa yang akan membuat sistem lebih "bukti masa depan"?
• Pertanyaan apa yang harus diajukan kepada klien / PM untuk membuat sistem lebih "bukti masa depan"?

Data adalah Raja

Saya pikir ini agak tidak masuk akal untuk mengharapkan aplikasi web sekitar tahun 2013 akan tetap beroperasi pada tahun 2053. Teknologi akan berubah. Platform akan datang dan pergi. HTML mungkin merupakan memori yang aneh saat itu. Tapi data Anda masih ada.

Jadi data adalah fokus utama Anda. Selama data Anda masih ada, orang akan dapat beradaptasi dengan teknologi baru apa pun. Pastikan skema data Anda dipikirkan dengan baik, dan cocok untuk ekspansi. Luangkan waktu Anda untuk menjelaskannya.

Mengenai aplikasi yang sebenarnya, perusahaan Anda mungkin benar di sini dalam memiliki arahan 'build from scratch'. Saya memelihara beberapa aplikasi web berumur 10+ tahun, dan saya sangat senang mereka tidak dikunci ke dalam sistem CMS yang berlaku tahun 2003. Mereka menggunakan kerangka yang dikembangkan di rumah, sangat sederhana. Saya pikir untuk hal seperti ini Anda lebih baik dengan kerangka kerja yang sangat dasar yang Anda buat secara khusus untuk kebutuhan proyek.

Namun kenyataannya, lebih dari 40 tahun, perusahaan (semoga) akan membuat beberapa layanan front-end dan back-end untuk beradaptasi dengan platform yang berkembang. Karena itu, saya menargetkan 5-10 tahun seumur hidup untuk setiap aplikasi yang menghadap pengguna.

Kami memproduksi perangkat lunak yang telah digunakan dengan membayar pelanggan selama lebih dari 20 tahun. Basis kode telah melampaui beberapa generasi alat kontrol sumber. Perangkat lunak kami mengenai semua poin Anda kecuali untuk tablet.

Beberapa masalah termasuk ESIGN dan UETA . Pengacara kami percaya bahwa kami perlu membuat catatan elektronik dapat dibaca selama minimal 10 tahun. Untuk dokumen yang dipertahankan utuh, Anda harus melihat ke PDF / A .

Untuk database Anda, jangan terlalu khawatir tentang normalisasi. Alih-alih, Anda harus khawatir tentang pencatatan segala sesuatu dan memiliki tabel audit yang melacak perubahan / penghapusan data. Saat meningkatkan versi, rencanakan pengujian versi baru secara paralel untuk waktu yang cukup untuk memastikan bahwa Anda mendapatkan data Anda dimigrasi. Pengujian versi baru ini juga mencakup sistem operasi baru - kami memiliki beberapa kejutan yang sangat tidak menyenangkan selama bertahun-tahun. Pertahankan media penginstalan dan kunci lisensi jika terjadi kemunduran. Uji cadangan. Jika Anda akan membuat serialisasi objek yang akan disimpan dalam database, lakukan sebagai XML alih-alih serialisasi yang disediakan oleh kerangka kerja pengembangan Anda.

Untuk staf Anda, basis kode jangka panjang membutuhkan memori jangka panjang. Idealnya Anda ingin orang di sekitar yang sudah ada sejak lama. Jika itu mustahil secara institusional, maka Anda perlu mendokumentasikan semuanya dalam sesuatu seperti wiki. Dan saran saya adalah wiki yang dapat dikaitkan dengan sistem pelacakan bug Anda.

Untuk basis kode Anda, pastikan Anda memiliki komentar dalam kode Anda. Bermigrasi dari satu sistem kontrol versi ke yang lain hampir selalu akan kehilangan komentar check-in Anda. Saya penggemar tes unit penamaan setelah nomor spec dan bug. Dengan begitu jika tes unit Test_Bug_1235 rusak, maka Anda tahu apa dan di mana melacak apa yang seharusnya diuji. Ini tidak "seksi" seperti penamaan tes Anda Check_File_Save_Networked_Drivestetapi tes semacam itu sulit untuk mundur ke spesifikasi, persyaratan atau bug seperti Test_requirement_54321_case_2.

Daripada mencoba mencari tahu bagaimana aplikasi ini akan masih beroperasi 20 tahun dari sekarang, saya pikir Anda harus menghabiskan enam bulan Anda memperbaiki masalah yang Anda temukan yang disebabkan oleh arsitek asli, menempatkan arsitektur yang masuk akal, kuat, dan bergerak maju dari sana.

De-normalisasi parsial dari suatu database tidak harus sepenuhnya tidak terduga dalam pengaturan medis. Beberapa bagian dari basis data medis memiliki karakteristik yang membuatnya cocok untuk model EAV (Entity / Attribute / Value) .

Jawaban dari perspektif front-end:

Jangan dengarkan semua orang yang mengatakan itu tidak dapat dilakukan, karena layanan web eksperimental San Francisco State University yang saya tulis bersama pada tahun 1996 akhirnya pergi ke surga Internet beberapa tahun yang lalu, dan tidak pernah memerlukan perbaikan kompatibilitas browser tunggal pada waktu itu ; itu hampir setengah dari target 40 tahun Anda. Dan front-end berbasis-JavaScript ini saya buat pada tahun 1998 untuk proyek Stanford Research Institute digantikan dengan sesuatu yang lebih mencolok beberapa tahun kemudian, tetapi tidak ada alasan UI asli masih tidak dapat berjalan hari ini dengan perbaikan kompatibilitas kecil.

Kuncinya adalah memastikan aplikasi Anda hanya menggunakan standar W3C / ECMA yang didukung secara luas dan memiliki desain yang bersih di bawah kendali Anda. Sementara banyak aplikasi web yang ditulis dengan teknologi era 90-an yang trendi tidak akan berfungsi dengan baik atau sama sekali hari ini, aplikasi web era 90-an yang ditulis dengan standar utama masih dilakukan. Mereka mungkin terlihat ketinggalan jaman, tetapi mereka bekerja.

Tujuannya di sini bukan untuk menulis aplikasi web yang akan naik di server mereka dan tetap di sana selama 40 tahun tanpa ada yang menyentuhnya lagi. Ini untuk membangun fondasi yang masih dapat digunakan puluhan tahun ke depan, yang dapat tumbuh untuk mendukung fitur-fitur baru tanpa harus dibangun kembali dari awal.

Pertama-tama, Anda harus membuat kode dengan standar resmi dan hanya dengan standar resmi. Tidak ada fitur JavaScript yang bukan bagian dari standar ECMAScript yang telah diratifikasi; ES5.1 adalah versi saat ini dan umumnya didukung sehingga aman untuk ditargetkan. Demikian juga, versi HTML5, CSS, dan Unicode saat ini bagus. Tidak ada fitur eksperimental JavaScript, CSS3 atau HTML (yang dengan awalan vendor atau tanpa perjanjian 100% antara browser). Dan tidak ada peretas yang kompatibel dengan peramban khusus. Anda dapat mulai menggunakan fitur baru setelah standar dan semua orang mendukungnya tanpa awalan.

Dukungan ES5 akan berarti menjatuhkan IE8 atau yang lebih lama, yang saya sarankan pula karena memerlukan peramban khusus peramban yang tidak akan berguna dalam beberapa tahun. Saya menyarankan Mode Ketat ES5 untuk kesempatan terbaik di umur panjang, yang sebenarnya menetapkan kompatibilitas browser dasar Anda di IE10 dan versi terbaru dari semua orang . Browser tersebut juga memiliki dukungan asli untuk banyak fitur validasi form HTML5 dan placeholder, yang akan berguna untuk waktu yang sangat lama.

Edisi baru ECMAScript mempertahankan kompatibilitas dengan versi yang lebih lama, jadi akan lebih mudah untuk mengadopsi fitur yang akan datang jika kode Anda ditulis sesuai dengan standar saat ini. Sebagai contoh, kelas yang didefinisikan menggunakan classsintaks yang akan datang akan sepenuhnya dipertukarkan dengan kelas yang didefinisikan dengan constructor.prototypesintaksis saat ini . Jadi dalam lima tahun pengembang dapat menulis ulang kelas ke dalam format ES6 berdasarkan file per file tanpa melanggar apa pun - dengan asumsi, tentu saja, bahwa Anda juga memiliki tes unit yang baik.

Kedua, hindari kerangka kerja aplikasi JavaScript yang trendi, terutama jika mereka mengubah cara Anda membuat kode aplikasi Anda. Backbone adalah hal yang paling disukai, kemudian SproutCore dan Ember, dan sekarang Angular adalah kerangka yang disukai semua orang untuk dipromosikan. Mereka mungkin berguna, tetapi mereka juga memiliki kesamaan: mereka sering merusak aplikasi dan memerlukan perubahan kode ketika versi baru keluar dan umur panjangnya dipertanyakan. Saya baru-baru ini memperbarui aplikasi 1,1 Angular ke 1,2, dan sedikit harus ditulis ulang. Demikian juga, beralih dari Backbone 2 ke 3 membutuhkan banyak perubahan HTML. Standar bergerak lambat karena suatu alasan, tetapi kerangka kerja ini bergerak cepat dan hal-hal yang melanggar secara berkala adalah biayanya.

Plus, standar resmi baru sering meninggalkan kerangka kerja lama yang usang, dan ketika itu terjadi kerangka kerja itu bermutasi (dengan melanggar perubahan) atau tertinggal. Anda tahu apa yang akan terjadi pada semua perpustakaan janji yang bersaing di dunia begitu ECMAScript 6 disahkan dan semua browser mendukung kelas Janji standarnya? Mereka akan menjadi usang dan pengembang mereka akan berhenti memperbarui mereka. Jika Anda memilih kerangka kerja yang tepat, kode Anda mungkin beradaptasi dengan cukup baik, dan jika Anda menebak dengan buruk Anda akan melihat refactoring besar.

Jadi, jika Anda berpikir untuk mengadopsi perpustakaan pihak ketiga atau kerangka kerja, tanyakan pada diri sendiri seberapa sulit untuk menghapus di masa depan. Jika kerangka kerja seperti Angular yang tidak dapat dihapus tanpa membangun kembali aplikasi Anda dari awal, itu pertanda baik itu tidak dapat digunakan dalam arsitektur 40 tahun. Jika ini adalah widget kalender pihak ketiga yang Anda abstraksi dengan middleware khusus, menggantinya akan memakan waktu beberapa jam.

Ketiga, berikan struktur aplikasi yang bagus dan bersih. Bahkan jika Anda tidak menggunakan kerangka kerja aplikasi Anda masih dapat memanfaatkan alat pengembang, membuat skrip, dan desain bersih yang bagus. Saya pribadi penggemar manajemen ketergantungan Closure Toolkit karena ringan dan biaya operasionalnya sepenuhnya dihapus saat membuat aplikasi Anda. LessCSS dan SCSS juga merupakan alat yang hebat untuk mengatur lembar gaya Anda dan membangun lembar gaya CSS berbasis standar untuk rilis.

Anda juga dapat mengatur kode Anda sendiri ke dalam kelas sekali pakai dengan struktur MVC. Itu akan membuatnya lebih mudah untuk kembali beberapa tahun ke depan dan tahu apa yang Anda pikirkan ketika Anda menulis sesuatu, dan hanya mengganti bagian-bagian yang membutuhkannya.

Anda juga harus mengikuti saran W3C dan menjaga informasi presentasi sepenuhnya dari HTML Anda. (Itu termasuk menipu seperti memberi elemen nama kelas presentasional, seperti "teks hijau besar" dan "lebar dua kolom"). Jika HTML Anda semantik dan CSS bersifat presentasional, akan jauh lebih mudah untuk mempertahankan dan mengadaptasinya ke platform baru di masa depan. Ini juga akan lebih mudah untuk menambahkan dukungan untuk browser khusus untuk orang buta atau cacat.

Keempat, mengotomatiskan tes Anda dan pastikan Anda memiliki cakupan hampir penuh. Tulis tes unit untuk setiap kelas, baik di sisi server atau di JavaScript. Di ujung depan, pastikan setiap kelas berkinerja sesuai dengan spesifikasinya di setiap browser yang didukung. Otomatiskan tes ini dari bot build Anda untuk setiap komit. Ini penting untuk umur panjang dan keandalan, karena Anda dapat menangkap bug lebih awal bahkan ketika browser saat ini mengaburkannya. Kerangka kerja pengujian berbasis Jasmine dan Google Penutupan baik.

Anda juga ingin menjalankan tes fungsional UI penuh, yang Selenium / WebDriver pandai. Pada dasarnya, Anda menulis sebuah program yang melangkah melalui UI Anda dan menggunakannya seolah-olah seseorang sedang mengujinya. Hubungkan mereka ke bot build juga.

Terakhir, karena orang lain telah menyebutkan data Anda adalah raja. Pikirkan model penyimpanan data Anda dan pastikan itu dibangun untuk bertahan lama. Pastikan skema data Anda solid, dan pastikan itu telah diuji secara menyeluruh di setiap komit. Dan pastikan arsitektur server Anda scalable. Ini bahkan lebih penting daripada apa pun yang Anda lakukan di ujung depan.

Mengesampingkan masalah harapan yang tidak masuk akal dari klien Anda dan berfokus pada masalah desain, saya tidak akan melangkah sejauh 40 tahun, tetapi masalah yang tampaknya Anda miliki, dari evolusi jangka panjang, adalah tepat untuk apa REST diciptakan untuk . Maksud saya sebenarnya REST sebagai gaya arsitektur, bukan pengembangan kata kunci yang begitu umum dikaitkan dengan istilah ini.

Untuk beberapa hal, orang salah REST karena saya gagal memasukkan cukup detail pada jenis desain media dalam disertasi saya. Itu karena saya kehabisan waktu, bukan karena saya pikir itu kurang penting daripada aspek lain dari REST. Demikian juga, saya curiga banyak orang yang salah karena mereka hanya membaca entri Wikipedia pada subjek, yang tidak berdasarkan sumber otoritatif.

Namun, saya pikir kebanyakan orang hanya membuat kesalahan bahwa itu seharusnya sederhana untuk merancang hal-hal sederhana. Pada kenyataannya, upaya yang diperlukan untuk merancang sesuatu berbanding terbalik dengan kesederhanaan hasilnya. Seiring gaya arsitektur berjalan, REST sangat sederhana.

REST adalah desain perangkat lunak dalam skala puluhan tahun : setiap detail dimaksudkan untuk mempromosikan umur panjang perangkat lunak dan evolusi independen.

http://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven#comment-724

Anda menyebutkan bahwa Anda bermaksud menggunakan antarmuka RESTful. Komentar itu dengan sendirinya menyarankan Anda harus melakukan penelitian serius ke dalamnya dan mencoba memahami apa sebenarnya REST. Anda mungkin mengaitkannya hanya dengan pemetaan metode HTTP ke operasi CRUD yang oleh sebagian besar orang dianggap REST, tetapi tidak ada hubungannya dengan itu.

Pikirkan REST sebagai formalisasi arsitektur web itu sendiri. Dalam satu atau lain cara, ada banyak bagian dari web yang ditulis satu dekade yang lalu atau lebih yang masih tersedia dan dapat digunakan dengan klien yang dibuat hari ini, jadi kami mendapatkan sesuatu yang benar di departemen itu. Ini akan banyak pekerjaan, saya jamin, karena melakukan REST dengan benar itu sulit, tetapi manfaat jangka panjang sepadan.

Setelah saya membaca pertanyaan dan jawaban lainnya (dipikirkan dengan sangat baik), saya berpikir bahwa saya akan meninggalkan dua sen saya juga. Catatan: Saya tidak perlu memelihara aplikasi / perangkat lunak yang benar-benar tua sama sekali. Apa yang saya gunakan sebagai referensi adalah aplikasi web hobi kerja-in-progress saya sendiri yang mengambil beberapa data pemerintah terbuka, mem-parsing dan menampilkannya dalam format yang berbeda. Aplikasi ini dimulai sebagai proyek di mana saya tidak sendirian dan di mana pemerintah baru saja mengumumkan akan menawarkan data ini kapan saja, entah bagaimana. Jadi sudah jelas bahwa banyak hal akan berubah seiring waktu. Dan mereka melakukannya. Apa yang saya pelajari darinya:

• Pisahkan dalam aplikasi-mini. Masing-masing sepenuhnya mampu memenuhi tugasnya sendiri. Ini membuat pergantian satu bagian sangat cepat, sangat aman dan sangat mudah. Dan ketika Anda harus kembali, tidak terlalu sulit untuk mengetahui mengapa sesuatu terjadi dan bagaimana Anda terjadi. Jika Anda atau orang lain harus mengubah sesuatu di lain waktu, lebih mudah untuk mengganti satu bagian daripada seluruh rangkaian hal.
• Dapatkan middleware / -layer konstan konstan yang digunakan untuk komunikasi antara berbagai bagian. Dalam hal ini saya menggunakan JSON, tetapi XML, ini atau standar serupa akan baik-baik saja. Mudah untuk diulang dan dapat diubah menjadi apa saja. Semua standar terbukti yang akan bertahan cukup lama. Bahkan jika data dasar dan / atau model penyimpanan akan berubah. Setiap aplikasi dapat menggunakan penyimpanan data mereka sendiri untuk tugas spesifiknya. Ini membuat jumlah data yang dipindai untuk tugas lebih kecil, sehingga lebih mudah untuk ditangani dan dipelihara dan lebih mudah dipertukarkan.
• Jangan khawatir tentang keputusan bahasa pemrograman. Itu akan berubah seiring waktu. Pastikan Anda menggunakan bahasa yang Anda sukai atau yang paling cocok dengan tugas.
• Pastikan penyimpanan data Anda "berskala horizontal" dan mudah untuk menyambungkan modul penyimpanan tambahan.
• Dapatkan poin umum (dalam kasus saya ini adalah URI) tempat aplikasi mini dipanggil dan / atau bertukar data.

Ringkasnya: Hal yang paling saya pedulikan adalah pemisahan masalah dan kemampuan pertukaran bagian yang ditugaskan untuk tugas. Anda hanya tahu bahwa dalam 40 tahun (bahkan dalam 5 atau 10) perangkat keras, antarmuka, penyimpanan, dll akan banyak berubah. Dan nantinya pengembang harus bereaksi terhadap perubahan itu dan bertukar bagian dari aplikasi Anda, baik itu wadah data atau bagian dari Antarmuka Pengguna.

Untuk membuat hal-hal "bukti masa depan" mungkin, rencanakan untuk perubahan. Artinya, cobalah yang paling sulit untuk tidak mengoptimalkan untuk apa pun selain kemampuan untuk dengan mudah berubah. Jadi tidak ada normalisasi, tidak ada validasi yang ketat, dan kelonggaran kopling longgar.

• Gunakan teknologi open-source utama. Untuk data, sistem sumber tertutup adalah sumber risiko utama karena seseorang tidak dapat merencanakan di mana perusahaan akan melakukan perubahan atau mengubah strategi, dengan mengambil semua akses ke data. Juga, proyek-proyek sumber terbuka kecil tanpa komunitas yang bersemangat juga lebih mungkin kehilangan dukungan.

• Gunakan database NoSQL tanpa skema. Jenis data tidak terstruktur yang digunakan hampir langsung dari buku teks untuk toko dokumen seperti MongoDB. Database relasional tradisional dan normalisasi mereka baik ketika Anda tahu bagaimana data Anda akan terstruktur, tapi itu benar-benar sebuah fiksi, terutama di sini. Biaya untuk mengubah skema dalam RDBS semakin besar seiring dengan perluasan sistem. Ketahuilah bahwa struktur apa pun yang dipilih sekarang akan berakhir berubah.

• Memisahkan sistem dengan banyak menggunakan standar yang diterima secara luas. Memecah semua akses data dan mutasi ke dalam layanan web adalah satu langkah menuju ini. Menggabungkannya dengan antrian pesan untuk mengirim perubahan dan hal itu akan membantu setiap bagian dari sistem mengubah bahasa atau teknologi dari waktu ke waktu.

OK, jadi saya akan mengatakan beberapa hal di sini yang mungkin akan sangat tidak populer, tetapi tetap dengan saya di sini.

Karena ini adalah proyek pertama Anda di mana data dan / atau aplikasi seharusnya bertahan selama 20+ tahun, dan Anda adalah yang memimpin proyek, Anda perlu mengambil langkah mundur dan berpikir tentang peluang proyek ini yang berhasil. . Karena mereka pada dasarnya di sebelah nol.

Anda perlu menghabiskan banyak waktu untuk fokus pada desain database dan melakukan yang benar. Agar proyek ini berhasil, Anda perlu membawa arsitek data ke dalam proyek, dan lebih cepat nanti. Tanpa seseorang yang berpengalaman dalam desain database, dan yang dipraktikkan dengan baik dalam menantikan bagaimana data dapat digunakan di masa depan, peluang data masih berguna setelah 5 tahun apalagi 40 tahun tidak ada yang ramping.

Mengharapkan dua orang (satu di antaranya memiliki gelar jr. Dev) untuk membangun sesuatu dari awal yang diperkirakan akan bertahan 40 tahun, mungkin tidak akan berhasil. Seharusnya ada tim yang terdiri dari banyak orang yang berpengalaman dalam bekerja dengan proyek-proyek besar seperti ini yang bekerja pada desain data, desain API dan desain aplikasi. Sesuatu seperti ini bukan proyek 2 orang.

Ingin mengikat proyek dengan sesuatu seperti Drupal menunjukkan mengapa proyek membutuhkan orang-orang yang terbiasa mengerjakan proyek semacam ini. Anda tidak ingin mengikat aplikasi dengan apa pun yang mungkin ketinggalan zaman hanya dalam beberapa tahun. Jika Anda melakukannya, menemukan seseorang untuk bekerja pada sistem dalam 5-10 tahun bisa menjadi sangat sulit dengan sangat cepat.

Saya akan mengambil saran ini kepada manajemen dan menjelaskan kepada mereka bahwa Anda perlu mendapatkan lebih banyak orang senior di proyek ini. Kalau tidak, proyek ini pasti akan gagal, dan Anda mungkin akan menjadi orang yang salah.

Aplikasi tidak perlu bertahan 40 tahun tanpa evolusi apa pun. Tapi, karena itu akan atau harus dibangun dari awal, itu masih bisa 'berfungsi'.

Apa yang paling penting adalah 'arsitektur data' yang memungkinkan stabilitas dan tata kelola serta dapat diperluas.

Kami telah merancang arsitektur data dan taksonomi yang hampir bisa bertahan di akhir kemanusiaan tetapi masih bisa diperluas. Anda harus menemukan orang DATA TAXONOMI / ARSITEKTUR DATA sejati untuk melakukan ini untuk Anda.

Kuncinya di sini adalah fokus pada basis data (seperti yang dikatakan beberapa orang di atas). Ini harus koheren dan sepenuhnya menggambarkan operasi. Perlu tumbuh dengan operasi saat ia berubah. Jika tidak mudah untuk berubah maka itu akan keluar dari tanggal dan itu adalah ciuman kematian. Sisanya relatif kurang penting.

Saya tidak setuju dengan mereka di atas yang menyarankan normalisasi tidak penting, meskipun selalu ada kasus di mana sistem saat ini tidak sesuai dengan pekerjaan. Dalam kasus ini denormalise tetapi pastikan database menangani penulisan / perubahan tambahan sebagai bagian dari transaksi atom. Dengan begitu Anda dapat mengabaikan masalah secara efektif hingga Anda dapat memperbaikinya.

Perusahaan tempat saya bekerja sebelum pensiun menjalankan sistem yang ditulis dari awal dan telah tumbuh hampir terus menerus selama 25 tahun, dan mencakup hampir semua aspek pengecer menengah. Aspek-aspek dari sistem ini yang saya rasa penting adalah:

• Integrasi sangat penting.
• Basis data harus benar dan dapat dipahami baik oleh TI maupun staf lainnya, sehingga diperlukan penamaan yang hampir paranoid pada penamaan. Kami memiliki tabel mnemonik yang didefinisikan yang kemudian digabungkan untuk membuat nama tabel dan bidang dan semua "kode" juga dinamai konstanta dan disimpan dalam struktur tabel EAV.
• Kami merangkum logika bisnis ke dalam pemicu basis data. Ini menyakitkan pada awalnya dan membutuhkan pekerjaan tambahan untuk mengirimkan pesan kesalahan kepada klien dan untuk memungkinkan pemicu untuk diubah secara fleksibel tanpa mengunci seluruh tabel pada beberapa sistem, tetapi ini dengan cepat menjadi penghemat waktu yang sangat besar, dan memaksa database menjadi jauh lebih benar. daripada sebaliknya.
• Asumsikan Anda akan menyimpan setidaknya tabel referensi (idealnya semuanya kecuali transaksi tercepat dan paling tidak penting) selama sistem, bahkan ketika "dihapus" sehingga referensi Anda benar.
• Karena hal di atas memastikan setiap pengidentifikasi unik dan nomor transaksi diukur untuk jangka panjang. (Awalnya saya dengan bercanda menyarankan bahwa mereka perlu bertahan sampai saya pensiun).

Saya sarankan menggunakan sumber acara dan perintah dan permintaan segregasi tanggung jawab . Ini terutama karena satu-satunya hal yang bisa Anda yakini adalah peristiwa yang sudah muncul. Jenis acara baru mungkin datang. Jadi, bahkan jika Anda menaruh pikiran berat pada model, yakin bahwa ini akan menjadi usang. Memigrasi semua data dengan setiap rilis mungkin tidak layak. Jadi yang terbaik adalah memiliki model yang sesuai dengan kebutuhan Anda saat ini dan yang dihitung dari peristiwa yang sudah direkam setiap kali Anda membutuhkannya dan kemudian bagikan peristiwa yang dihitung dari keadaan saat ini dari model itu.

Juga memiliki pengujian dalam pikiran. Jika aplikasi sedang digunakan dalam sepuluh tahun dari sekarang, penguji harus memastikan bahwa ia masih melakukan apa yang seharusnya dilakukan. Jadi buatlah integrasi menguji aplikasi Anda semudah mungkin.