4.98 score from hupso.pl for:
afsharm.com



HTML Content


Titleafshar mohebbi – a technical weblog by a software developer

Length: 65, Words: 9
Description pusty

Length: 0, Words: 0
Keywords pusty
Robots
Charset UTF-8
Og Meta - Title pusty
Og Meta - Description pusty
Og Meta - Site name pusty
Tytuł powinien zawierać pomiędzy 10 a 70 znaków (ze spacjami), a mniej niż 12 słów w długości.
Meta opis powinien zawierać pomiędzy 50 a 160 znaków (łącznie ze spacjami), a mniej niż 24 słów w długości.
Kodowanie znaków powinny być określone , UTF-8 jest chyba najlepszy zestaw znaków, aby przejść z powodu UTF-8 jest bardziej międzynarodowy kodowaniem.
Otwarte obiekty wykresu powinny być obecne w stronie internetowej (więcej informacji na temat protokołu OpenGraph: http://ogp.me/)

SEO Content

Words/Characters 6947
Text/HTML 49.83 %
Headings H1 1
H2 16
H3 0
H4 0
H5 0
H6 0
H1
afshar mohebbi
H2
recent posts
recent comments
archives
categories
meta
a good architecture for an asp.net core application
an outsource experience
creating a framework to be used as a base for many other applications
review structure of a web application that i’m working on
software component re-use in asp.net and django and is it really beneficial?
finding a good front end solution for a semi single page web application
selecting a web framework based on reusability and pluggability of components
using cloud storage services
developing an asp.net core project on ubuntu
modifying decade-old asp.net application
posts navigation
H3
H4
H5
H6
strong
1- layers
2- repository
3- unit of work
4- handling validations in application or in database?
5- a class for each service
6- misc points
cultural differences
not putting enough time
the team has not worked with each other before this
large data
upgrade
internal mechanism
do everything through application channel
creating packed mega aps.net controls
conclusion
projects structure
interfaces
soft delete
authorization
using dtos to access data layer
update:
update
update 2
b
i
em
Bolds strong 23
b 0
i 0
em 0
Zawartość strony internetowej powinno zawierać więcej niż 250 słów, z stopa tekst / kod jest wyższy niż 20%.
Pozycji używać znaczników (h1, h2, h3, ...), aby określić temat sekcji lub ustępów na stronie, ale zwykle, użyj mniej niż 6 dla każdego tagu pozycje zachować swoją stronę zwięzły.
Styl używać silnych i kursywy znaczniki podkreślić swoje słowa kluczowe swojej stronie, ale nie nadużywać (mniej niż 16 silnych tagi i 16 znaczników kursywy)

Statystyki strony

twitter:title pusty
twitter:description pusty
google+ itemprop=name pusty
Pliki zewnętrzne 19
Pliki CSS 8
Pliki javascript 11
Plik należy zmniejszyć całkowite odwołanie plików (CSS + JavaScript) do 7-8 maksymalnie.

Linki wewnętrzne i zewnętrzne

Linki 139
Linki wewnętrzne 2
Linki zewnętrzne 137
Linki bez atrybutu Title 138
Linki z atrybutem NOFOLLOW 0
Linki - Użyj atrybutu tytuł dla każdego łącza. Nofollow link jest link, który nie pozwala wyszukiwarkom boty zrealizują są odnośniki no follow. Należy zwracać uwagę na ich użytkowania

Linki wewnętrzne

skip to content #content
- mailto:afshar.mohebbi@gmail.com

Linki zewnętrzne

afshar mohebbi http://weblog.afsharm.com/
- https://ir.linkedin.com/in/afsharm
- http://twitter.com/mohebbi
- http://github.com/afsharm
- https://www.instagram.com/afsharm
- http://stackoverflow.com/users/167670/
a good architecture for an asp.net core application http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/
an outsource experience http://weblog.afsharm.com/2017/04/an-outsource-experience/
creating a framework to be used as a base for many other applications http://weblog.afsharm.com/2016/11/creating-a-framework-to-be-used-as-a-base-for-many-other-applications/
review structure of a web application that i’m working on http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
software component re-use in asp.net and django and is it really beneficial? http://weblog.afsharm.com/2016/11/software-component-re-use-in-asp-net-and-django-and-is-it-really-beneficial/
review structure of a web application that i’m working on – afshar mohebbi http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
a good architecture for an asp.net core application http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/#comment-18403
a good architecture for an asp.net core application – afshar mohebbi http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/
review structure of a web application that i’m working on http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/#comment-18402
an outsource experience – afshar mohebbi http://weblog.afsharm.com/2017/04/an-outsource-experience/
developing an asp.net core project on ubuntu http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/#comment-18326
an outsource experience – afshar mohebbi http://weblog.afsharm.com/2017/04/an-outsource-experience/
review structure of a web application that i’m working on http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/#comment-18325
dheeraj tiwari https://youprogrammer.com
finding a good front end solution for a semi single page web application http://weblog.afsharm.com/2016/11/finding-a-good-front-end-solution-for-a-semi-single-page-web-application/#comment-18207
may 2017 http://weblog.afsharm.com/2017/05/
april 2017 http://weblog.afsharm.com/2017/04/
november 2016 http://weblog.afsharm.com/2016/11/
october 2016 http://weblog.afsharm.com/2016/10/
may 2016 http://weblog.afsharm.com/2016/05/
april 2016 http://weblog.afsharm.com/2016/04/
february 2016 http://weblog.afsharm.com/2016/02/
january 2016 http://weblog.afsharm.com/2016/01/
december 2015 http://weblog.afsharm.com/2015/12/
november 2015 http://weblog.afsharm.com/2015/11/
october 2015 http://weblog.afsharm.com/2015/10/
september 2015 http://weblog.afsharm.com/2015/09/
august 2015 http://weblog.afsharm.com/2015/08/
uncategorized http://weblog.afsharm.com/category/uncategorized/
log in http://weblog.afsharm.com/wp-login.php
entries rss http://weblog.afsharm.com/feed/
comments rss http://weblog.afsharm.com/comments/feed/
wordpress.org https://wordpress.org/
a good architecture for an asp.net core application http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/
here http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/
1 comment on a good architecture for an asp.net core application http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/#comments
an outsource experience http://weblog.afsharm.com/2017/04/an-outsource-experience/
here http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
here http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/
http://weblog.afsharm.com/2017/04/an-outsource-experience/
experience http://weblog.afsharm.com/tag/experience/
outsource http://weblog.afsharm.com/tag/outsource/
leave a comment on an outsource experience http://weblog.afsharm.com/2017/04/an-outsource-experience/#respond
creating a framework to be used as a base for many other applications http://weblog.afsharm.com/2016/11/creating-a-framework-to-be-used-as-a-base-for-many-other-applications/
last one http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
if it is a good idea http://weblog.afsharm.com/2016/11/selecting-a-web-framework-based-on-reusability-and-pluggability-of-components/
at all http://weblog.afsharm.com/2016/11/selecting-a-web-framework-based-on-reusability-and-pluggability-of-components/
what's the best platform to do that http://weblog.afsharm.com/2016/11/software-component-re-use-in-asp-net-and-django-and-is-it-really-beneficial/
http://weblog.afsharm.com/2016/11/creating-a-framework-to-be-used-as-a-base-for-many-other-applications/
asp.net http://weblog.afsharm.com/tag/asp-net/
inflexibility http://weblog.afsharm.com/tag/inflexibility/
retrospective http://weblog.afsharm.com/tag/retrospective/
2 comments on creating a framework to be used as a base for many other applications http://weblog.afsharm.com/2016/11/creating-a-framework-to-be-used-as-a-base-for-many-other-applications/#comments
review structure of a web application that i’m working on http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
retrospective https://en.wikipedia.org/wiki/scrum_(software_development)#review_and_retrospective
develop is done mostly in ubuntu http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/
- http://weblog.afsharm.com/wp-content/uploads/2016/11/retro.jpg
here http://weblog.afsharm.com/2017/05/a-good-architecture-for-an-asp-net-core-application/
http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/
asp.net http://weblog.afsharm.com/tag/asp-net/
restrospective http://weblog.afsharm.com/tag/restrospective/
review http://weblog.afsharm.com/tag/review/
scrum http://weblog.afsharm.com/tag/scrum/
3 comments on review structure of a web application that i’m working on http://weblog.afsharm.com/2016/11/review-structure-of-a-web-application-that-im-working-on/#comments
software component re-use in asp.net and django and is it really beneficial? http://weblog.afsharm.com/2016/11/software-component-re-use-in-asp-net-and-django-and-is-it-really-beneficial/
http://weblog.afsharm.com/2016/11/software-component-re-use-in-asp-net-and-django-and-is-it-really-beneficial/
asp.net http://weblog.afsharm.com/tag/asp-net/
django http://weblog.afsharm.com/tag/django/
re-use http://weblog.afsharm.com/tag/re-use/
1 comment on software component re-use in asp.net and django and is it really beneficial? http://weblog.afsharm.com/2016/11/software-component-re-use-in-asp-net-and-django-and-is-it-really-beneficial/#comments
finding a good front end solution for a semi single page web application http://weblog.afsharm.com/2016/11/finding-a-good-front-end-solution-for-a-semi-single-page-web-application/
spas https://en.wikipedia.org/wiki/single-page_application
this http://codebrief.com/2012/01/the-top-10-javascript-mvc-frameworks-reviewed/
this https://www.lullabot.com/articles/choosing-the-right-javascript-framework-for-the-job
this http://noeticforce.com/best-javascript-frameworks-for-single-page-modern-web-applications
backbone.js http://backbonejs.org/
here http://wildermuth.com/2016/11/21/looking-for-the-goldilocks-of-web-frameworks
http://weblog.afsharm.com/2016/11/finding-a-good-front-end-solution-for-a-semi-single-page-web-application/
backbone.js http://weblog.afsharm.com/tag/backbone-js/
front end http://weblog.afsharm.com/tag/front-end/
js http://weblog.afsharm.com/tag/js/
3 comments on finding a good front end solution for a semi single page web application http://weblog.afsharm.com/2016/11/finding-a-good-front-end-solution-for-a-semi-single-page-web-application/#comments
selecting a web framework based on reusability and pluggability of components http://weblog.afsharm.com/2016/11/selecting-a-web-framework-based-on-reusability-and-pluggability-of-components/
- http://weblog.afsharm.com/wp-content/uploads/2016/11/reusability.png
not fully object oriented http://stackoverflow.com/questions/3325343/why-python-is-not-full-object-oriented
smaller than rails http://www.indeed.com/jobtrends/django%2c+ruby+on+rails.html
here http://weblog.afsharm.com/2016/01/choosing-a-new-development-platform-for-a-net-developer/
here http://weblog.afsharm.com/2015/12/learning-railsruby-or-node-js/
here http://www.paysa.ir/articles/%d8%a7%d9%86%d8%aa%d8%ae%d8%a7%d8%a8-%d8%b2%d8%a8%d8%a7%d9%86-%d8%a8%d8%b1%d9%86%d8%a7%d9%85%d9%87-%d9%86%d9%88%db%8c%d8%b3%db%8c-%d9%88-%d9%81%d9%86%d8%a7%d9%88%d8%b1%db%8c-%d8%ac%d8%af%db%8c%d8%af/
here http://weblog.afsharm.com/2015/10/trying-new-programming-languages-and-platforms/
http://weblog.afsharm.com/2016/11/selecting-a-web-framework-based-on-reusability-and-pluggability-of-components/
django http://weblog.afsharm.com/tag/django/
rails http://weblog.afsharm.com/tag/rails/
web framework http://weblog.afsharm.com/tag/web-framework/
2 comments on selecting a web framework based on reusability and pluggability of components http://weblog.afsharm.com/2016/11/selecting-a-web-framework-based-on-reusability-and-pluggability-of-components/#comments
using cloud storage services http://weblog.afsharm.com/2016/10/using-cloud-storage-services/
onedrive-d https://github.com/xybu/onedrive-d-old
http://weblog.afsharm.com/2016/10/using-cloud-storage-services/
cloud http://weblog.afsharm.com/tag/cloud/
cloud storage http://weblog.afsharm.com/tag/cloud-storage/
dropbox http://weblog.afsharm.com/tag/dropbox/
google drive http://weblog.afsharm.com/tag/google-drive/
onedrive http://weblog.afsharm.com/tag/onedrive/
leave a comment on using cloud storage services http://weblog.afsharm.com/2016/10/using-cloud-storage-services/#respond
- http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/
developing an asp.net core project on ubuntu http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/
trying http://weblog.afsharm.com/2016/01/choosing-a-new-development-platform-for-a-net-developer/
migrate http://weblog.afsharm.com/2015/10/trying-new-programming-languages-and-platforms/
linux http://weblog.afsharm.com/2016/01/one-year-with-ubuntu/
asp.net core http://www.asp.net/core
yeoman http://yeoman.io/
- http://weblog.afsharm.com/wp-content/uploads/2016/10/asp-net-core-debug-ubuntu-xfce.jpg
- http://weblog.afsharm.com/wp-content/uploads/2016/10/omni-sharp-high-cpu-usage.jpg
- http://weblog.afsharm.com/wp-content/uploads/2016/10/xfce-chrome-crashes.jpg
http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/
asp.net core http://weblog.afsharm.com/tag/asp-net-core/
ubuntu http://weblog.afsharm.com/tag/ubuntu/
visual studio code http://weblog.afsharm.com/tag/visual-studio-code/
xfce http://weblog.afsharm.com/tag/xfce/
2 comments on developing an asp.net core project on ubuntu http://weblog.afsharm.com/2016/10/developing-an-asp-net-core-project-on-ubuntu/#comments
modifying decade-old asp.net application http://weblog.afsharm.com/2016/05/modifying-decade-old-asp-net-application/
we migrated its hosting from windows server 2003 to windows server 2012 r2 successfully http://weblog.afsharm.com/2016/04/asp-net-webform-2-0-work-in-windows-server-2012-r2-again/
http://weblog.afsharm.com/2016/05/modifying-decade-old-asp-net-application/
asp.net http://weblog.afsharm.com/tag/asp-net/
legacy http://weblog.afsharm.com/tag/legacy/
leave a comment on modifying decade-old asp.net application http://weblog.afsharm.com/2016/05/modifying-decade-old-asp-net-application/#respond
page 2 http://weblog.afsharm.com/page/2/
page 3 http://weblog.afsharm.com/page/3/
next page http://weblog.afsharm.com/page/2/
proudly powered by wordpress https://wordpress.org/

Zdjęcia

Zdjęcia 18
Zdjęcia bez atrybutu ALT 7
Zdjęcia bez atrybutu TITLE 17
Korzystanie Obraz ALT i TITLE atrybutu dla każdego obrazu.

Zdjęcia bez atrybutu TITLE

http://1.gravatar.com/avatar/9b59b8c28023fa973234518e442128cc
wp-content/uploads/2017/04/linkedin.png
wp-content/uploads/2017/04/twitter.png
wp-content/uploads/2017/04/github.png
wp-content/uploads/2017/04/instagram.png
http://weblog.afsharm.com/wp-content/uploads/2017/04/mail.png
/wp-content/uploads/2017/04/stackoverflow.png
http://weblog.afsharm.com/wp-content/uploads/2017/05/layers-791x1024.jpg
http://weblog.afsharm.com/wp-content/uploads/2017/04/keep_calm_and_outsource-257x300.png
http://weblog.afsharm.com/wp-content/uploads/2016/11/green-turtle-300x159.png
http://weblog.afsharm.com/wp-content/uploads/2016/11/inflex-150x150.png
http://weblog.afsharm.com/wp-content/uploads/2016/11/reusability.png
http://weblog.afsharm.com/wp-content/uploads/2016/10/cloud-storage-logo.jpg
http://weblog.afsharm.com/wp-content/uploads/2016/10/asp-net-core-debug-ubuntu-xfce-825x510.jpg
http://weblog.afsharm.com/wp-content/uploads/2016/10/asp-net-core-debug-ubuntu-xfce.jpg
http://weblog.afsharm.com/wp-content/uploads/2016/10/omni-sharp-high-cpu-usage.jpg
http://weblog.afsharm.com/wp-content/uploads/2016/10/xfce-chrome-crashes.jpg

Zdjęcia bez atrybutu ALT

http://1.gravatar.com/avatar/9b59b8c28023fa973234518e442128cc
wp-content/uploads/2017/04/linkedin.png
wp-content/uploads/2017/04/twitter.png
wp-content/uploads/2017/04/github.png
wp-content/uploads/2017/04/instagram.png
http://weblog.afsharm.com/wp-content/uploads/2017/04/mail.png
/wp-content/uploads/2017/04/stackoverflow.png

Ranking:


Alexa Traffic
Daily Global Rank Trend
Daily Reach (Percent)









Majestic SEO











Text on page:

skip to content afshar mohebbi a technical weblog by a software developer menu and widgets .net developer moving to linux with a passion of entrepreneurship. search for: recent posts a good architecture for an asp.net core application an outsource experience creating a framework to be used as a base for many other applications review structure of a web application that i’m working on software component re-use in asp.net and django and is it really beneficial? recent commentsreview structure of a web application that i’m working on – afshar mohebbi on a good architecture for an asp.net core applicationa good architecture for an asp.net core application – afshar mohebbi on review structure of a web application that i’m working onan outsource experience – afshar mohebbi on developing an asp.net core project on ubuntuan outsource experience – afshar mohebbi on review structure of a web application that i’m working ondheeraj tiwari on finding a good front end solution for a semi single page web applicationarchives may 2017 april 2017 november 2016 october 2016 may 2016 april 2016 february 2016 january 2016 december 2015 november 2015 october 2015 september 2015 august 2015 categories uncategorized meta log in entries rss comments rss wordpress.org a good architecture for an asp.net core application from june 2016 that asp.net core 1.0 released i have used it at least in 2 projects. each of them learned me new points especially in project architecture including layering, di, mapping and dtos. while ago i wrote about my experience here. now i am trying to enhance previous experiences and describe a project based on the enhanced structure. 1- layers one of most important decisions is project layers. personally i do not like multiple layers, but here i choose to have 3 layers for a good reason. i want to hide database from presentation. i do not like controllers or web apis be aware of internal structure of tables and fields. because in this way: designing controller actions and web apis are easier as they do not have to know everything about internal table designs security is higher. as asp.net binding does not fill input parameters with data from user. indeed as services are not aware of complete model (table) design, they can not bind it incorrect or malicious inputs of the user. avoiding dirty checking mechanism of orms. if you receive an entire db model, there is a change that entity framework detects it as a dirty object and tries to save it in database while you did not mean it. avoiding confusing mappings by have only needed properties it is my suggested layering: asp.net core project layersasp.net core project layers[/caption]asp.net core project layers[/caption]asp.net core project layers[/caption] user works with presentation layer. presentation layer is aware of only service layer and transfer data to it via dtos. service layer in turn communicates with data access layer via database models. in other hands service layer isolates presentation and data access layers from each other. data access layer contains anything that should not be visible to presentation layer. presentation layer can be supposed as a thin layer as it contains database models and dbcontext only. service layer contains repositories and all services. presentation layer contains asp.net controllers, cshtml and css files. 2- repository entity framework’s dbcontext itself is a repository itself. normally there is no need to warp its add method. unless in enterprise projects that special processes are needed on each add or update. for example setting last update time in a specific field. adding extra repository on dbcontext/dbset makes it harder if you want to update just some fields of a record. 3- unit of work unit of work is usually not a tough problem. you simply call savechanges() of dbcontext on dispose method of the controller. this provides automatic unit of work to all actions. but wait, there is a special case that this is not a good idea. what if a problem occurs while committing changes to the database? you will not be aware of that. worse than it your changes fail to commit to database and the user will not be even aware of it. because when dispose method is called, user response has been sent to the user’s machine and it is too late to inform him/her. my idea is not using dispose method and call savechanges() manually on each controller action so you can detect possible errors and inform the user about it. 4- handling validations in application or in database? one popular approach to do database validations is to commit data changes into database and see if everything goes well or not. for example putting duplicate values into a unique column does not cause errors in application side, but when it is sent to database it will generate an error complaining about duplicate values. there 2 approaches here. first, leave it as is and let database to control our business logic for us. this approach almost needs no effort to implement as everything is passed to database side. but it requires accurate model definition as that will be converted to database schema. this approach is dependent on underlying database. if underlying database changes, there is chance that behavior of the system changes. one thing that works on mssql 2014 may not work as same as sqlite. this approach also make unit tests hard. as some business logic is not in the code so can be unit tested. second approach in not relying on database. all validations and rules are checked in application itself. here there is no dependency on database and unit test can be applied well but this need extra codes and also have performance penalty as database is hit more than once. at least one time for validations and one time for committing changes to the database. normally my personal choice is to do validations in application side. 5- a class for each service i has been used to use some big classes for services and use multiple dto or viewmodel or model classes to get input from asp.net binder from user input. but now i think it is not a good idea. it was causing large service classes that can be considered god classes along with multiple model classes that contains only simple properties and no methods. now i prefer to use a separate class for each single service. it contains all model properties and needed code for implementing that service. it is more oop and it is more manageable. in asp.net core i use iserviceprovider to the class so it can get needed services form asp.net core internal di. see a sample code: void init(iserviceprovider serviceprovider) { _usermanager = (usermanager)serviceprovider.getservice(typeof(usermanager)); _matchservice = (matchservice)serviceprovider.getservice(typeof(matchservice)); } 12345 void init(iserviceprovider serviceprovider) { _usermanager = (usermanager)serviceprovider.getservice(typeof(usermanager)); _matchservice = (matchservice)serviceprovider.getservice(typeof(matchservice)); } 6- misc points model’s id type to be guid not auto increment integer value. it has better database performance as you do not need to query to database again to get assigned id. not using interfaces at all. it is not useful. use bower or similar tools to install client side frameworks. be careful while using autmapper. properties can be simply different in 2 sides and no error is raised when it is. posted on may 3, 2017may 3, 20171 comment on a good architecture for an asp.net core application an outsource experience recently i have been working on an outsource/remote project on a software solution consisting of both web and mobile parts. as i am always interested in outsource projects, any experience on it is important for me. so i am trying to document my experience on this project in an almost none technical perspective. in this sample project we had project management but it was not enough. not complying sprint patterns was a main issue. new issues were adding to current sprints without noticing that this reduces planning effects. a similar issue was losing focus by working tasks outsides of current sprint. in some cases, there were tasks which resolved with only 0.5 hour and there were tasks were resolved with about 12 hours. i mean tasks were not broken into same pieces. some of them were actually more than 1 tasks and some of them could be simply merged with other tasks. too many changes in requirements really caused delays and was hard to apply. i know in agile environments, changes are normal, but i mean too many changes. consider too many changes in database table structures that caused many other changes in back-end and even apis. this project had enough amounts of documents from first day. but in some parts this was not clear enough. documentation problem was getting more problematic as project was growing and new people was adding to the project. it was better that question/answers by team members be added to the documentation but it was not. documentation could be more up-to-date and be more structured. i forced to implement soft delete in the system tables but after a while i realized that we were not really needing it. all in all that customer wanted was logging record changes. i am not sure that call it bad communication or letting product owner to take technical decisions. not using full featured alm tools was causing negative impact on productivity. having a tool to publish latest versions automatically based on each git push could help us having more up-to-date test server. not all team members were comfortable with written culture of remote working environments. in a team spread in several cities, it was important that any activity logged in jira, slack, emails, … any member should be able to have information about other works and tasks. this is more important when team members common time are not very large. as a team that works in different time zones with different work schedules we had a bad problem that was long wait time between actions. member a books a bug in bug tracking system, hours or even 1 day later member b want to resolve the bug but need more info, he adds comments but member b see it 1 day later and it is going on. you see resolving a bug can take several days. one of members a or b could have solved this bug with higher problem solving skills. member a could be able to understand the possible bug by trying more inputs and putting system in more states. and member b could be more successful by thinking on the behalf of a and try to solve the issue with less round trips. team organization was not so ideal. breaking team to web part and mobile part caused tracking issues harder. we could be more agile if 2 parts was able to run other parts code by themselves. but when in a small team, works are passed via test servers not in source code, then more time is needed to test an even small task. i believe that this kind of issues have almost 3 roots. cultural differences that forces us to have different impressions of team roles. for example, from scrum master or back-end developer. another root is not putting enough time for controlling the team and take actions on weaknesses. and last one in my point of view is that the team has not worked with each other before this. a team needs time to reach its full power. team members need time to get acquainted which each other. for a technical review on this project, see here and here. posted on april 23, 2017april 23, 2017tags experience, outsourceleave a comment on an outsource experience creating a framework to be used as a base for many other applications oh, interesting, received another retrospective just few days after last one. we have developed a base asp.net webfrom framework named abc and then developed a series of web applications based on it on 2010/2011. one of them is def that is currently (late 2016) in production heavily and i guess will be in production at least till 2021 or even 2025 (no retirement plan yet). def is dealing with a database more than 10,000,000 records and is used country wide as a national project. def is encountering performance problems and is under constant but small changes of the client. many companies specially those that are not very technical at managerial level love to write code once but use it in many projects more than once. this is why many it companies have internal frameworks and many people like myself are searching if it is a good idea at all and if yes, what's the best platform to do that. creating abc and making def and other applications based on it is a good sample for this approach. i'm gonna to review its real weaknesses as it has been in production for few years now. large data abc has been used as base project of many applications but no one were dealing with large amount of database records as def. at the other hand abc was not designed to deal with that large amount of data. so def has performance issues more than other abc based projects. performance issues in turn causing other issues relate to save some records in situations that system load is high. upgrade as abc is base framework and many applications based on it are in production and some of them have multiple instances, so upgrading abc is hard. suppose i want to upgrade a component in abc to enhance some features, this upgrade may cause problems in others, at least i can not be sure that this upgrade is safe for all applications. in def case we needed to upgrade nhibernate and did it in painful and very lengthy process. slow internal mechanism like upgrade problem, we have difficulties in changing internal mechanisms and designs. for example changing transaction management is somehow necessary for def but it must be done through abc. and as others are using abc too, it is not an easy way, and sometimes it is impossible to be accomplished. as a result def is forced to live with problems that we know why exists and if def was standalone, how can be corrected. do everything through application channel for a small application that can be run from a shared host, it is not a bad idea if every operation is done via web application itself. but in a large application like def there are situations where other tools are needed. for example we have batch operations that take likely 30 or 60 minutes to complete. a good tool is to use windows services to do this type of work. but def uses asp.net and iis to do batches that is not good. many application pool restarts occur during batch or lengthy operations. also they reduce speed of current logged users and decrease iis resources and possibly cause secondary problems. another example is handling a database table with large record count. we handled it hardly in the application while a better way was to introduce a secondary database and define jobs to move old records to it so main database remaining lighter. inflexibility creating packed mega aps.net controls if you are familiar with asp.net webforms you know that we have plenty of asp.net controls available there, like drop-down-box. in abc we have had created some mega controls like them to do bigger operations. think that they were similar to telerik or dundas controls, but larger and wider. for example a grid that was able to do paging, sorting and searching. in theory they were very useful and time saving but they were tightly coupled with other internal structure of the abc and was very inflexible. conclusion general purpose frameworks are seen very promising while not used, but in production many cavities are explored. they are good when used in short term and very very similar applications. if you want speed and flexibility think more about “creating each application from scratch” strategy. posted on november 26, 2016november 26, 2016tags asp.net, inflexibility, retrospective2 comments on creating a framework to be used as a base for many other applications review structure of a web application that i’m working on there is a work-flow in scrum called retrospective. it is about reviewing work done in a sprint. i love the idea, i think talking and communication in a software development team is very important. inspired from scrum retrospective i'd like to have a review on architecture and design of a project that recently i've been involved in. the project is not finished yet but i think it is a good time to review its structures. the project back-end is implemented by asp.net mvc core and entity framework core and is serving both web api and server backed contents (asp.net mvc). develop is done mostly in ubuntu but also in windows too. projects structure while project is not very big and complex and have about 20 tables on the database we decided to have 4 projects. one for domain, dtos and contracts named domain, another for mainly business logic called core, another for web project itself that contains cshtmls, controllers and wwwroot directory called web and another for unit tests called test. i do agree this is a very common project structure for asp.net web applications but i saw not benefit over them except than a simple categorizing that also was achievable with directories. i think it was better to have 2 projects, one for web (combining domain, core and web) and another for test. interfaces programming against interfaces are very popular in c#. it has gained more popularity with wide usage of dependency injection in asp.net. also asp.net core have a built in dependency injection that has increased popularity programming against interfaces. we followed this manner in our project. we create an interface per each service class. we have no mockups in our unit tests so i think using so many interfaces are a bit over-engineering because we have no interface in our project that has more than one implementation. having large number of interfaces just decreased development velocity. adding each new method needed changes in two place, service itself and interface that it was implementing. soft delete soft delete means not deleting database records physically, but instead keep them in database and set a filed in each record named isdeleted to true. so in the application soft deleted records are not showed or processed. we add this feature to the application so we can track data changes and do not allow any data being really loosed. for this purpose we could have used logging mechanism in a way if a record is deleted a log is added that says who deleted what data and when. implementing soft delete imposed many manual data integrity check to the application. with delete of each record we must check if any dependent item exists or not, if so prevent deletion. authorization i personally made authorization over-engineering. i checked roles in both controllers and services in many cases. my emphasis on separation of controllers and services was a bit high. no entry to the app exists other than mvc controllers and api controllers (they are same in asp.net core). so checking roles in controllers in enough. using dtos to access data layer many application designs allow a direct access to database models. for example controllers action get a mymodel instance directly and pass it to dbset or services to save it. it is dangerous because orm dirty checking mechanism may save them in the database in mistake. in this project i used a dto to pass data to or get data from crud services. so controllers are not aware of database models. it increased volume of development but i think it saves us from mysterious data updates in the database. update: second part of this post can be found here. posted on november 23, 2016may 3, 2017tags asp.net, restrospective, review, scrum3 comments on review structure of a web application that i’m working on software component re-use in asp.net and django and is it really beneficial? ‌i am an asp.net developer for years. in many companies and projects that i worked for there is constant need for re-usable components. some companies were completely serious about it so based their business on it. when i'm doing software projects on my own management (as project manager or as freelancer) i encounter this subject again. realistic or not realistic, it is very favorable if we could use previously developed components in new projects. it would be very time saving specially in repetitive projects. code re-use exists in different levels of asp.net. you can use html helpers or user controls to share components between projects, you also can use services like logger or authentication in several projects. there is a type of component reuse in asp.net that is used by modules like elmah that is based on http modules or middle wares. none of them are a component re-use that i need. what i need is a complete set of component re-use. i need all core and ui elements all together. for example in logger example, i need core logic and all needed ui all together in a manner that i can plug into a new application so other components of the application can communicate an integrate with it. i know there is a solution for asp.net that is called area that approximately do what i need. it do its re-use in view (ui) well. i just copy files into its directory. but i it no designed a really separate component. it is forced to be aware of mother application's internal functionality specially on database design. maybe it is the reason that asp.net mvc area is not very popular. i've read a lot about django that is re-use friendly by design. i see it is based on apps. also i see that there is an app sharing web site for it. but never used it in a real project. by thinking more and more on software re-use (in the context of web development) i realize that not every component re-use is suitable for the application. there is trade-off here. if you want to have a re-usable app then you have to develop it as generic as you can. that itself is causing complexity and creating bug and even consumes more time for development. when you start using a component among several projects you must carefully think of every change you made in the application. each change must be confirmed as backward compatible as others are using your app. so maintenance would be hard. apparently this is the reason many web development teams do not employ re-usable components a lot. there is at least one situation that this model of software re-use makes sense. when you produce a re-usable app for a limited range of projects and limited period of time and when you are intended to use your app only in a family of project, that would better suites. here it is good that django applications are developed in this manner by default, whether you wan to re-use it or not. posted on november 19, 2016tags asp.net, django, re-use1 comment on software component re-use in asp.net and django and is it really beneficial? finding a good front end solution for a semi single page web application i am in middle of decision making about what technique or library should i use in front end for a typical web application. major section of this application is done with asp.net mvc with full back end approach. so very little front end development and ajax calls exists except for cascading drop downs or implementing auto-complets. every operations are done via server post backs. when you do a crud or other operations your request is sent to server, then the result is rendered in server then returned to client and finally is shown. with this manner, front end can not be complicated very much. pages can not have too many elements and//or too many operations. for large operations, more than one page is needed. a page for main operation then a page for sub-operation that typically is navigated from a main list page. but the problem began from where that some page are wanted to have more than one operation. for example a page for crud some models and some sub-pages in it for complementary operations. supposing that no post-back is allowed here, we would need front end development here. interacting with dom and reading/updating them needs plenty jquery code and also need few server apis and ajax calls to them. as much as the pages goes larger and need for interaction with user gets higher, for example getting user's confirmation or opening more dialog boxes, volume and complexity of front end code increases. so need of decreasing complexity and development time arises. here we have 3 options. first, do not allow much front end development and handle all the application with back end mvc only. front end pages will be simple this way. pages can not have more than one operation and every operation will cause a post back. number of total pages will decrease as each single operation need a separate page. second we can allow multi-operation pages but use no ajax calls. that means jquery is used to opening dialog boxes and getting user data but instead of using ajax, the form is posted to the server so a post-back occurs. this technique have inflexibility because it not easy to show dialog boxes or getting confirmations from user. everything is posted to server, then possible errors are detected then error messages are sent back to the client. also no state can be maintained. after page is returned from server, active controls or even data that was entered in inputs will be lost. because of these in-flexibilities this technique is not applicable very much. third technique is to get help from javascript libraries and frameworks developed for this problem. this way all functionality we need for front end, including good user interaction, low code complexity and low implement time (except for learning time and setup time) is reached. cons is learning time, setup time and overhead that it may produce. if we go for third solution, a good choice is to use mvc/mvvm js frameworks that are mostly used for spas. our goal is also is spa but only for some sections of the web application not all of them. famous js frameworks for spas are angular.js and ember.js. but they are too large for our problem. so a smaller one must be selected from several comparisons including this, this and this. form them i feel that backbone.js (mvp) and knockout.js (mvvm) are better choices. backbone.js uses more familiar pattern that is mvp and i read somewhere that knockout.js development is slow and community is getting decreasing. so backbone.js could be final choice. update after advocating wiht my friend i decided to add a 4th solution: doing front end manipulations with pure jquery/ajax code. this code may be lengthy but have less overhead than employing a spa framework like angular.js or backbone.js. update 2 shawn wildermuth also did a comparison recently. find it here. posted on november 16, 2016november 23, 2016tags backbone.js, front end, js3 comments on finding a good front end solution for a semi single page web application selecting a web framework based on reusability and pluggability of components there are plenty comparison of web frameworks on the internet. many of them compare web frameworks in general, some of them compare web frameworks with performance measure. some are comparing in learning curve, popularity, architecture, speed of development, etc. but i am interested to focus on reusability and pluggability of components. in a web development team it is good to be able to use previously developed portions of project in new projects. for example many projects have membership or accounting section. they can be developed once and used more than once in different projects. you can even think of ticketing or organizational structure management across different separate web projects. goal is reduce development effort during development mid level web projects. django is introducing itself as to be so, but how about rails, asp.net, mean or other common web frameworks? django has administrative crud interface that can save much time during development. dhango's moto is “the web framework for perfectionists with deadlines”. every application in django is consisted of apps. each app can implement an independent field of business. django claims that you can join different apps to to create a complete web application. django has good documentations but its learning curve is high. it seems efficient for database based applications. django is not fully object oriented. it is not as fast as node.js but does not force you to build everything from scratch. it also seem to have less batteries than node.js and rails. its job market is even smaller than rails and asp.net. rails is opinionated, so many settings and conventions are set by default. rails developers can learn it faster and develop with more rapidly. it is not very good at performance but have strong community. rails is popular in mac users while. it also is easier while deploying as cloud solutions have better support of it. its rapid development can compete with reusablity feature that django claims. previously i wrote about the subject here, here, here and here. what is your opinions and experiences? posted on november 7, 2016tags django, rails, web framework2 comments on selecting a web framework based on reusability and pluggability of components using cloud storage services as a person who is practicing remote working, freelancing and working with distributed teams, using cloud storage services like google drive is inevitable. each service has its own pros and cons especially when you live in place that has serious internet constraints and international sanctions. using cloud storage services helps you to be more organized and productive. you want to send a copy of a file to colleagues and after updating it, sending updated copies again? using emails are tedious and error prone. you can put the file into a cloud storage system and share it with colleagues. so everyone have access to it. if you or your colleagues update the file, so no need to send new file to each other, everyone just get new file automatically. cloud storage services save history of file for you, so you can see changes over time or download an older version if you want. cloud storage services provide good ways for notifications to collaborators when someone changes a file or adds new files to a shared space. they also keep track of conflicts and are good for alone people that just want to share their own files among their own devices like pcs, notebooks, tablets and mobile phones. not using a cloud storage service in a distributed team is in some degree like not using source control systems among developers of a team. despite all advantages of using cloud storage services, there are also disadvantages. they tend to consume huge amounts of your bandwidth. some of them are expensive. using cloud storage services speeds up you get confused with different operating systems, file formats, utilities, etc. you are using ms office while others put libre office file formats into the shared space. you can edit a specific file in your pc but your tablet does not have an editor for it. your macbook machine works well with a cloud storage system while there is no suitable cloud storage client for your tablet. and don't forget that security is a big concern. cloud storage for many users specially those who has android devices, default selection is google drive. it has online editors and have good integration with android devices but its big problem is us sanctions. due to sanctions, its desktop client for windows can not be downloaded from sanctioned countries. i guess if you download it with some work-arounds there would be still restrictions using it because apis are still on the internet and you must hope they are not restricted for sanctioned countries. another popular choice is microsoft onedrive. it has excellent integration with micorosoft office online. its services are many less expensive than other services. but there are some problems with it. it has no official client for linux. there is an un-official project for it called onedrive-d, but it is not working very well. onedrive stopped its service to sanctioned countries from october 2016. for linux users residing in sanctioned countries, dropbox is a good choice. it is accessible from these countries, it is easily installed on linux and even works good with android. though it is an expensive service. it also have office online for editing files online. if you are a linux user using libreoffice and wants to be able edit your files in android and in online dropbox be careful. there is no android version and no online version of libreoffice. you have to save your files in ms office format and use ms office for android and ms office online. posted on october 31, 2016october 31, 2016tags cloud, cloud storage, dropbox, google drive, onedriveleave a comment on using cloud storage services developing an asp.net core project on ubuntu it's a long time that i'm trying to migrate from windows/.net to linux. but job market have more demands on .net other than none microsoft technologies. my hope was on asp.net core. it was not very good at the beta/rc time but now that is published in final version, my mind has been changed. it now works good on ubuntu. at start i created several test projects with asp.net core on both windows and ubuntu. i wanted to be sure that asp.net core is capable enough to rely on it in a real world project. i tried to test all aspects of mvc, web api, razor, nuget packages, ef core, identity core, internal di/ioc, project.json, sqlite, unit testing and tooling include visual studio code, debugging, unit testing, auto complete, code formatting, shortcuts, etc. i tested them on a windows machine and on an ubuntu machine with both unity and xfce desktops. all tests showed that i will not encounter a big problem utilizing asp.net core itself as first place and using it in ubuntu at second place. using .net core in ubuntu is as same as windows except that you rely more on terminal than gui. using dotnet commands are exactly same in both windows and ubuntu. same names, same switches, same operations and same outputs. it was really good thing that they are exactly same. but when it comes to tooling it is different. while your ide in both platforms is visual studio code they do not differ very much but if you are used to use visual studio 2015 then you can understand how deep is difference between visual studio code and visual studio 2015. the latter have a full integration and do everything you need with just pressing some shortcuts. but visual studio code needs many configurations to behave like visual studio 2015. debugging in visual studio code is not as easy as visual studio 2015, you need some level skill of operating system to be able to debug codes in visual studio code. my good friend from visual studio 2015, intellisense, was not working at all at first days. now that it works, it does not work as good as in visual studio 2015. it shows many un-related items too. btw having visual studio code in ubuntu is like a miracle. it is very similar to visual studio 2015, it has code highlighting, similar shortcuts (unity desktop), good integration with git, real time compile (to show errors in the code), etc. did i mentioned that you can use yeoman as a substitution of visual studio 2015 templating system that is absent in visual studio code? the project i am working on it in ubuntu is a regular web application with parts rendered via mvc and parts delivered to a mobile app as web api. in development environment i use sqlite as database backend but for production we will be using ms-sql server. ef core works good despite its constraints in verison 1. sqlite in other part also works good as development environment database. it does not allow complete support of ef migration but instead works same from ubuntu and from windows. one thing that works great is that the code i'm working on is working exactly same in windows and ubuntu. i change code in my ubuntu machine, commit and push them to the server then pull it from a windows machine and then continue my development from my windows machine, no matter i have switched from one os to another os. code behaves same in both oses and runs exactly same. additionally code can be developed and run in both visual studio code and visual studio 2015 as same. the only consideration is directory structure be designed compatible with structure that visual studio 2015 knows about. i haven't yet deployed the project into a linux machine as our client probably prefer to use windows for it. but i hope hosting would not be a problem too. as a long term .net developer i am very exited about cross platform feature that microsoft has been added to .net but frankly i'm a bit worry about it. i'm not sure if microsoft would continue this way on linux or not. i am afraid that developers using .net in linux would not be as big as microsoft imagines then abandon it. i started developing asp.net core on ubuntu on unity (standard desktop with ubuntu). everything was good except high cpu usage. this problem was not caused by asp.net core instead it was caused by 'hud service' from unity. for this reason i decided to try xfce also. it is a light desktop that does not have hud service high cpu usage problem but have problems of its own kind. first thing you encounter is that shortcuts are very very different than unity. i lost even my ctrl+f3 (for searching keywords in visual studio code). in rare situations it has problems with high cpu usage of visual studio code (omnisharp) but bigger problem is regular crashes of my applications like toggl, my favorite time tracker, and even google chrome. though i'm still using xfce but think i would soon switch back to unity and find another solution for hud service high cpu usage. please see some pictures of my experiences: posted on october 19, 2016tags asp.net core, ubuntu, visual studio code, xfce2 comments on developing an asp.net core project on ubuntu modifying decade-old asp.net application if you are planning to maintain an application for more than a decade then be careful. i'm in middle of a case of modifying an asp.net webform application back to 2006 so 10 years old from now. this application is live for now and it is running for no problem. one month ago we migrated its hosting from windows server 2003 to windows server 2012 r2 successfully. i can imagine if no modification is needed it would be live for another more decade despite vast changing world of web development and .net. but our current problem is different than relocating it from a 2003 windows to a 2012 one. we want to modify it so change or add behaviors to it. some modifications are easy to apply. for example if an html/css change is wanted it can be done by modifying aspx/ascx files easily. but modifications in code behind aspx.cs and ascx.cs file are not easy. because our application is compiled and no cs file exists in hosting iis. so changes must be applied in source code then published and converted to dll files then deployed on the hosting iis. our application has dependencies to other assemblies like ajaxcontroltoolkit 2006 and we have not exact version of them currently. so our application simply wont build and wont publish easily. at first glance i thought the only choice that we have is to upgrade all dependencies to current version that is impossible. from ten years ago til now many of third party libraries have been discontinued or have many breaking changes. even asp.net itself has been changed very much. fortunately i got a good solution. that was simple and trivial but i didn't noticed it before. we had published version of the application that means we currently have needed assemblies that are referenced from application. no matters if they are very old or we have not access to their source code. they are valid and executable .net assemblies that can be referenced from any .net application. posted on may 25, 2016tags asp.net, legacyleave a comment on modifying decade-old asp.net application posts navigation page 1 page 2 page 3 next page proudly powered by wordpress


Here you find all texts from your page as Google (googlebot) and others search engines seen it.

Words density analysis:

Numbers of all words: 6820

One word

Two words phrases

Three words phrases

and - 2.93% (200)
the - 2.89% (197)
for - 1.91% (130)
not - 1.54% (105)
that - 1.51% (103)
use - 1.5% (102)
app - 1.38% (94)
are - 1.32% (90)
all - 1.11% (76)
one - 1.06% (72)
application - 0.95% (65)
.net - 0.95% (65)
work - 0.94% (64)
you - 0.92% (63)
but - 0.91% (62)
project - 0.88% (60)
per - 0.88% (60)
base - 0.82% (56)
service - 0.82% (56)
have - 0.82% (56)
data - 0.82% (56)
asp.net - 0.79% (54)
with - 0.78% (53)
this - 0.69% (47)
web - 0.67% (46)
very - 0.65% (44)
here - 0.65% (44)
develop - 0.65% (44)
other - 0.62% (42)
our - 0.6% (41)
can - 0.6% (41)
any - 0.57% (39)
database - 0.56% (38)
good - 0.56% (38)
from - 0.56% (38)
need - 0.54% (37)
end - 0.54% (37)
code - 0.53% (36)
ide - 0.53% (36)
more - 0.53% (36)
was - 0.51% (35)
core - 0.5% (34)
using - 0.48% (33)
able - 0.47% (32)
many - 0.47% (32)
some - 0.44% (30)
change - 0.43% (29)
user - 0.43% (29)
time - 0.41% (28)
thin - 0.4% (27)
its - 0.4% (27)
orm - 0.4% (27)
problem - 0.37% (25)
has - 0.37% (25)
get - 0.35% (24)
there - 0.35% (24)
let - 0.35% (24)
layer - 0.35% (24)
framework - 0.34% (23)
control - 0.34% (23)
used - 0.34% (23)
works - 0.34% (23)
studio - 0.32% (22)
visual - 0.32% (22)
projects - 0.32% (22)
page - 0.32% (22)
than - 0.32% (22)
form - 0.32% (22)
file - 0.32% (22)
changes - 0.31% (21)
development - 0.31% (21)
each - 0.31% (21)
them - 0.31% (21)
back - 0.29% (20)
soft - 0.29% (20)
2016 - 0.29% (20)
services - 0.29% (20)
like - 0.28% (19)
post - 0.28% (19)
team - 0.28% (19)
too - 0.28% (19)
also - 0.28% (19)
component - 0.26% (18)
unit - 0.26% (18)
ubuntu - 0.26% (18)
def - 0.25% (17)
log - 0.25% (17)
test - 0.25% (17)
operation - 0.25% (17)
structure - 0.25% (17)
call - 0.25% (17)
they - 0.25% (17)
cause - 0.25% (17)
about - 0.25% (17)
every - 0.23% (16)
windows - 0.23% (16)
then - 0.23% (16)
it. - 0.23% (16)
wan - 0.23% (16)
real - 0.23% (16)
cloud - 0.23% (16)
now - 0.23% (16)
working - 0.23% (16)
differ - 0.22% (15)
model - 0.22% (15)
add - 0.22% (15)
2015 - 0.22% (15)
same - 0.22% (15)
on. - 0.22% (15)
want - 0.22% (15)
view - 0.22% (15)
when - 0.22% (15)
table - 0.22% (15)
django - 0.21% (14)
were - 0.21% (14)
example - 0.21% (14)
even - 0.21% (14)
your - 0.21% (14)
storage - 0.21% (14)
server - 0.21% (14)
source - 0.19% (13)
think - 0.19% (13)
controller - 0.19% (13)
front - 0.19% (13)
while - 0.19% (13)
thing - 0.19% (13)
applications - 0.19% (13)
re-use - 0.19% (13)
cons - 0.19% (13)
comment - 0.19% (13)
put - 0.18% (12)
own - 0.18% (12)
needed - 0.18% (12)
abc - 0.18% (12)
based - 0.18% (12)
may - 0.18% (12)
posted - 0.18% (12)
see - 0.18% (12)
record - 0.18% (12)
main - 0.18% (12)
low - 0.18% (12)
large - 0.18% (12)
member - 0.18% (12)
review - 0.18% (12)
different - 0.18% (12)
sent - 0.18% (12)
experience - 0.18% (12)
system - 0.16% (11)
will - 0.16% (11)
design - 0.16% (11)
another - 0.16% (11)
high - 0.16% (11)
part - 0.16% (11)
provide - 0.16% (11)
api - 0.16% (11)
itself - 0.15% (10)
new - 0.15% (10)
implement - 0.15% (10)
interface - 0.15% (10)
would - 0.15% (10)
bug - 0.15% (10)
projects. - 0.15% (10)
been - 0.15% (10)
frameworks - 0.15% (10)
save - 0.15% (10)
solution - 0.15% (10)
could - 0.15% (10)
how - 0.15% (10)
controllers - 0.15% (10)
mac - 0.15% (10)
only - 0.15% (10)
layers - 0.13% (9)
files - 0.13% (9)
hit - 0.13% (9)
issue - 0.13% (9)
operations - 0.13% (9)
product - 0.13% (9)
side - 0.13% (9)
linux - 0.13% (9)
class - 0.13% (9)
set - 0.13% (9)
software - 0.13% (9)
november - 0.13% (9)
internal - 0.13% (9)
both - 0.13% (9)
way - 0.13% (9)
mvc - 0.13% (9)
update - 0.13% (9)
office - 0.13% (9)
action - 0.13% (9)
delete - 0.13% (9)
current - 0.12% (8)
client - 0.12% (8)
try - 0.12% (8)
tool - 0.12% (8)
machine - 0.12% (8)
really - 0.12% (8)
approach - 0.12% (8)
because - 0.12% (8)
components - 0.12% (8)
error - 0.12% (8)
manager - 0.12% (8)
into - 0.12% (8)
version - 0.12% (8)
big - 0.12% (8)
popular - 0.12% (8)
comments - 0.12% (8)
late - 0.12% (8)
developer - 0.12% (8)
access - 0.12% (8)
developed - 0.12% (8)
one. - 0.12% (8)
architecture - 0.12% (8)
unity - 0.12% (8)
i'm - 0.12% (8)
special - 0.12% (8)
outsource - 0.12% (8)
here. - 0.12% (8)
everything - 0.12% (8)
performance - 0.1% (7)
called - 0.1% (7)
mean - 0.1% (7)
drive - 0.1% (7)
rails - 0.1% (7)
choice - 0.1% (7)
full - 0.1% (7)
contains - 0.1% (7)
presentation - 0.1% (7)
upgrade - 0.1% (7)
done - 0.1% (7)
must - 0.1% (7)
much - 0.1% (7)
type - 0.1% (7)
better - 0.1% (7)
does - 0.1% (7)
complete - 0.1% (7)
tasks - 0.1% (7)
til - 0.1% (7)
ten - 0.1% (7)
tries - 0.1% (7)
first - 0.1% (7)
2016tags - 0.1% (7)
pages - 0.1% (7)
hard - 0.1% (7)
problems - 0.1% (7)
via - 0.1% (7)
online - 0.1% (7)
creating - 0.1% (7)
check - 0.1% (7)
aware - 0.1% (7)
just - 0.1% (7)
idea - 0.1% (7)
2017 - 0.1% (7)
application. - 0.1% (7)
what - 0.1% (7)
auto - 0.09% (6)
parts - 0.09% (6)
dto - 0.09% (6)
interfaces - 0.09% (6)
allow - 0.09% (6)
project. - 0.09% (6)
issues - 0.09% (6)
gets - 0.09% (6)
several - 0.09% (6)
ajax - 0.09% (6)
document - 0.09% (6)
android - 0.09% (6)
october - 0.09% (6)
enough - 0.09% (6)
similar - 0.09% (6)
method - 0.09% (6)
small - 0.09% (6)
most - 0.09% (6)
know - 0.09% (6)
spa - 0.09% (6)
is. - 0.09% (6)
show - 0.09% (6)
direct - 0.09% (6)
members - 0.09% (6)
once - 0.09% (6)
old - 0.09% (6)
over - 0.09% (6)
input - 0.09% (6)
records - 0.09% (6)
specially - 0.09% (6)
production - 0.09% (6)
share - 0.09% (6)
hand - 0.09% (6)
valid - 0.09% (6)
day - 0.09% (6)
i’m - 0.09% (6)
exists - 0.09% (6)
second - 0.09% (6)
controls - 0.09% (6)
learn - 0.09% (6)
technical - 0.07% (5)
easy - 0.07% (5)
less - 0.07% (5)
live - 0.07% (5)
had - 0.07% (5)
me. - 0.07% (5)
asp.net, - 0.07% (5)
complex - 0.07% (5)
usage - 0.07% (5)
sure - 0.07% (5)
recent - 0.07% (5)
take - 0.07% (5)
except - 0.07% (5)
context - 0.07% (5)
under - 0.07% (5)
publish - 0.07% (5)
after - 0.07% (5)
solve - 0.07% (5)
short - 0.07% (5)
pass - 0.07% (5)
mohebbi - 0.07% (5)
afshar - 0.07% (5)
caused - 0.07% (5)
drop - 0.07% (5)
feature - 0.07% (5)
track - 0.07% (5)
getting - 0.07% (5)
run - 0.07% (5)
again - 0.07% (5)
force - 0.07% (5)
mechanism - 0.07% (5)
commit - 0.07% (5)
least - 0.07% (5)
exact - 0.07% (5)
case - 0.07% (5)
edit - 0.07% (5)
modify - 0.07% (5)
possible - 0.07% (5)
did - 0.07% (5)
single - 0.07% (5)
business - 0.07% (5)
well - 0.07% (5)
validations - 0.07% (5)
important - 0.07% (5)
database. - 0.07% (5)
desktop - 0.07% (5)
classes - 0.07% (5)
format - 0.07% (5)
apis - 0.07% (5)
backbone.js - 0.07% (5)
countries - 0.07% (5)
microsoft - 0.07% (5)
find - 0.07% (5)
models - 0.07% (5)
dbcontext - 0.06% (4)
re-usable - 0.06% (4)
errors - 0.06% (4)
xfce - 0.06% (4)
their - 0.06% (4)
till - 0.06% (4)
onedrive - 0.06% (4)
crud - 0.06% (4)
load - 0.06% (4)
leave - 0.06% (4)
html - 0.06% (4)
long - 0.06% (4)
core, - 0.06% (4)
dtos - 0.06% (4)
april - 0.06% (4)
exactly - 0.06% (4)
search - 0.06% (4)
encounter - 0.06% (4)
not. - 0.06% (4)
properties - 0.06% (4)
level - 0.06% (4)
manner - 0.06% (4)
deleted - 0.06% (4)
sanctioned - 0.06% (4)
decade - 0.06% (4)
create - 0.06% (4)
trying - 0.06% (4)
instead - 0.06% (4)
retrospective - 0.06% (4)
ubuntu. - 0.06% (4)
23, - 0.06% (4)
turn - 0.06% (4)
years - 0.06% (4)
scrum - 0.06% (4)
previous - 0.06% (4)
deal - 0.06% (4)
modifying - 0.06% (4)
adding - 0.06% (4)
amount - 0.06% (4)
integration - 0.06% (4)
.net. - 0.06% (4)
problem. - 0.06% (4)
simply - 0.06% (4)
entity - 0.06% (4)
cpu - 0.06% (4)
logic - 0.06% (4)
implementing - 0.06% (4)
mid - 0.06% (4)
etc. - 0.06% (4)
shortcuts - 0.06% (4)
environment - 0.06% (4)
multiple - 0.06% (4)
separate - 0.06% (4)
- 0.06% (4)
documentation - 0.06% (4)
causing - 0.06% (4)
companies - 0.06% (4)
field - 0.06% (4)
here, - 0.06% (4)
dom - 0.06% (4)
iis - 0.06% (4)
management - 0.06% (4)
careful - 0.06% (4)
learning - 0.06% (4)
mobile - 0.06% (4)
speed - 0.06% (4)
sprint - 0.06% (4)
void - 0.06% (4)
sqlite - 0.06% (4)
users - 0.06% (4)
actions - 0.06% (4)
query - 0.06% (4)
developing - 0.06% (4)
simple - 0.06% (4)
google - 0.06% (4)
place - 0.06% (4)
having - 0.06% (4)
person - 0.06% (4)
start - 0.06% (4)
operations. - 0.06% (4)
complexity - 0.06% (4)
read - 0.06% (4)
flexibility - 0.06% (4)
plug - 0.06% (4)
needs - 0.06% (4)
reason - 0.06% (4)
help - 0.06% (4)
changes. - 0.06% (4)
alm - 0.06% (4)
others - 0.06% (4)
technique - 0.06% (4)
tests - 0.06% (4)
hosting - 0.06% (4)
wanted - 0.06% (4)
situation - 0.06% (4)
unity. - 0.04% (3)
light - 0.04% (3)
decided - 0.04% (3)
yet - 0.04% (3)
2015. - 0.04% (3)
domain, - 0.04% (3)
reduce - 0.04% (3)
too. - 0.04% (3)
debug - 0.04% (3)
decrease - 0.04% (3)
inflexibility - 0.04% (3)
same. - 0.04% (3)
continue - 0.04% (3)
plenty - 0.04% (3)
term - 0.04% (3)
rely - 0.04% (3)
2015, - 0.04% (3)
published - 0.04% (3)
libre - 0.04% (3)
fully - 0.04% (3)
decision - 0.04% (3)
apps - 0.04% (3)
section - 0.04% (3)
calls - 0.04% (3)
job - 0.04% (3)
developers - 0.04% (3)
send - 0.04% (3)
internet - 0.04% (3)
among - 0.04% (3)
assemblies - 0.04% (3)
server, - 0.04% (3)
much. - 0.04% (3)
final - 0.04% (3)
friend - 0.04% (3)
dialog - 0.04% (3)
os. - 0.04% (3)
boxes - 0.04% (3)
code. - 0.04% (3)
comparison - 0.04% (3)
pluggability - 0.04% (3)
list - 0.04% (3)
jquery - 0.04% (3)
reusability - 0.04% (3)
middle - 0.04% (3)
colleagues - 0.04% (3)
expensive - 0.04% (3)
asp.net. - 0.04% (3)
online. - 0.04% (3)
hope - 0.04% (3)
bit - 0.04% (3)
switch - 0.04% (3)
hud - 0.04% (3)
easily - 0.04% (3)
directory - 0.04% (3)
dropbox - 0.04% (3)
popularity - 0.04% (3)
means - 0.04% (3)
still - 0.04% (3)
devices - 0.04% (3)
despite - 0.04% (3)
download - 0.04% (3)
previously - 0.04% (3)
it, - 0.04% (3)
third - 0.04% (3)
roles - 0.04% (3)
modification - 0.04% (3)
who - 0.04% (3)
default - 0.04% (3)
tablet - 0.04% (3)
though - 0.04% (3)
point - 0.04% (3)
projects, - 0.04% (3)
during - 0.04% (3)
none - 0.04% (3)
enough. - 0.04% (3)
consider - 0.04% (3)
hour - 0.04% (3)
tools - 0.04% (3)
sample - 0.04% (3)
dependency - 0.04% (3)
hard. - 0.04% (3)
personal - 0.04% (3)
service. - 0.04% (3)
iserviceprovider - 0.04% (3)
back-end - 0.04% (3)
people - 0.04% (3)
higher - 0.04% (3)
solved - 0.04% (3)
code, - 0.04% (3)
root - 0.04% (3)
few - 0.04% (3)
resolve - 0.04% (3)
between - 0.04% (3)
forced - 0.04% (3)
added - 0.04% (3)
bad - 0.04% (3)
remote - 0.04% (3)
common - 0.04% (3)
make - 0.04% (3)
dependent - 0.04% (3)
designs - 0.04% (3)
tables - 0.04% (3)
user. - 0.04% (3)
bind - 0.04% (3)
dirty - 0.04% (3)
inputs - 0.04% (3)
experiences - 0.04% (3)
enhance - 0.04% (3)
finding - 0.04% (3)
beneficial? - 0.04% (3)
semi - 0.04% (3)
including - 0.04% (3)
ago - 0.04% (3)
checking - 0.04% (3)
layers[/caption] - 0.04% (3)
inform - 0.04% (3)
automatic - 0.04% (3)
detect - 0.04% (3)
putting - 0.04% (3)
almost - 0.04% (3)
dispose - 0.04% (3)
last - 0.04% (3)
should - 0.04% (3)
models. - 0.04% (3)
services. - 0.04% (3)
repository - 0.04% (3)
itself. - 0.04% (3)
days - 0.04% (3)
recently - 0.04% (3)
shared - 0.04% (3)
where - 0.04% (3)
high. - 0.04% (3)
situations - 0.04% (3)
applications. - 0.04% (3)
platform - 0.04% (3)
changing - 0.04% (3)
wide - 0.04% (3)
lengthy - 0.04% (3)
searching - 0.04% (3)
currently - 0.04% (3)
plan - 0.04% (3)
named - 0.04% (3)
designed - 0.04% (3)
batch - 0.04% (3)
occur - 0.04% (3)
occurs - 0.03% (2)
idea. - 0.03% (2)
actions. - 0.03% (2)
formats - 0.03% (2)
editor - 0.03% (2)
database? - 0.03% (2)
advantages - 0.03% (2)
that. - 0.03% (2)
systems - 0.03% (2)
tend - 0.03% (2)
consume - 0.03% (2)
26, - 0.03% (2)
operating - 0.03% (2)
committing - 0.03% (2)
savechanges() - 0.03% (2)
official - 0.03% (2)
setting - 0.03% (2)
linux. - 0.03% (2)
normally - 0.03% (2)
countries, - 0.03% (2)
codes - 0.03% (2)
build - 0.03% (2)
slow - 0.03% (2)
harder - 0.03% (2)
fields - 0.03% (2)
countries. - 0.03% (2)
makes - 0.03% (2)
specific - 0.03% (2)
extra - 0.03% (2)
drive. - 0.03% (2)
2016november - 0.03% (2)
side. - 0.03% (2)
converted - 0.03% (2)
passed - 0.03% (2)
effort - 0.03% (2)
sanctions. - 0.03% (2)
constraints - 0.03% (2)
distributed - 0.03% (2)
in. - 0.03% (2)
behavior - 0.03% (2)
relate - 0.03% (2)
support - 0.03% (2)
checked - 0.03% (2)
underlying - 0.03% (2)
rapid - 0.03% (2)
first, - 0.03% (2)
values - 0.03% (2)
handling - 0.03% (2)
purpose - 0.03% (2)
seem - 0.03% (2)
ways - 0.03% (2)
alone - 0.03% (2)
space. - 0.03% (2)
goes - 0.03% (2)
everyone - 0.03% (2)
market - 0.03% (2)
updating - 0.03% (2)
duplicate - 0.03% (2)
applied - 0.03% (2)
suppose - 0.03% (2)
emails - 0.03% (2)
i've - 0.03% (2)
careful. - 0.03% (2)
mapping - 0.03% (2)
dtos. - 0.03% (2)
lost - 0.03% (2)
decade-old - 0.03% (2)
maintain - 0.03% (2)
webform - 0.03% (2)
needed. - 0.03% (2)
secondary - 0.03% (2)
wrote - 0.03% (2)
deployed - 0.03% (2)
result - 0.03% (2)
matter - 0.03% (2)
personally - 0.03% (2)
cross - 0.03% (2)
usage. - 0.03% (2)
decisions - 0.03% (2)
2006 - 0.03% (2)
2003 - 0.03% (2)
applicationa - 0.03% (2)
wont - 0.03% (2)
uses - 0.03% (2)
changed - 0.03% (2)
referenced - 0.03% (2)
wordpress - 0.03% (2)
posts - 0.03% (2)
dependencies - 0.03% (2)
iis. - 0.03% (2)
especially - 0.03% (2)
imagine - 0.03% (2)
2012 - 0.03% (2)
points - 0.03% (2)
rss - 0.03% (2)
easily. - 0.03% (2)
modifications - 0.03% (2)
easier - 0.03% (2)
machine, - 0.03% (2)
tooling - 0.03% (2)
testing - 0.03% (2)
world - 0.03% (2)
useful - 0.03% (2)
layer. - 0.03% (2)
larger - 0.03% (2)
tested - 0.03% (2)
other. - 0.03% (2)
saving - 0.03% (2)
node.js - 0.03% (2)
libreoffice - 0.03% (2)
cshtml - 0.03% (2)
general - 0.03% (2)
31, - 0.03% (2)
only. - 0.03% (2)
migrate - 0.03% (2)
layers[/caption]asp.net - 0.03% (2)
object - 0.03% (2)
impossible - 0.03% (2)
familiar - 0.03% (2)
skill - 0.03% (2)
compile - 0.03% (2)
regular - 0.03% (2)
mega - 0.03% (2)
security - 0.03% (2)
through - 0.03% (2)
debugging - 0.03% (2)
bigger - 0.03% (2)
receive - 0.03% (2)
created - 0.03% (2)
difference - 0.03% (2)
behave - 0.03% (2)
avoiding - 0.03% (2)
css - 0.03% (2)
claims - 0.03% (2)
need. - 0.03% (2)
programming - 0.03% (2)
modules - 0.03% (2)
elements - 0.03% (2)
together - 0.03% (2)
communicate - 0.03% (2)
logged - 0.03% (2)
logger - 0.03% (2)
wait - 0.03% (2)
realistic - 0.03% (2)
subject - 0.03% (2)
later - 0.03% (2)
hours - 0.03% (2)
tracking - 0.03% (2)
against - 0.03% (2)
books - 0.03% (2)
area - 0.03% (2)
well. - 0.03% (2)
automatically - 0.03% (2)
suitable - 0.03% (2)
realize - 0.03% (2)
development. - 0.03% (2)
communication - 0.03% (2)
teams - 0.03% (2)
compatible - 0.03% (2)
git - 0.03% (2)
apps. - 0.03% (2)
functionality - 0.03% (2)
dealing - 0.03% (2)
copy - 0.03% (2)
design. - 0.03% (2)
server. - 0.03% (2)
lot - 0.03% (2)
push - 0.03% (2)
(as - 0.03% (2)
adds - 0.03% (2)
increased - 0.03% (2)
content - 0.03% (2)
showed - 0.03% (2)
example, - 0.03% (2)
kind - 0.03% (2)
breaking - 0.03% (2)
manual - 0.03% (2)
worked - 0.03% (2)
before - 0.03% (2)
over-engineering - 0.03% (2)
project, - 0.03% (2)
2017tags - 0.03% (2)
number - 0.03% (2)
reach - 0.03% (2)
keep - 0.03% (2)
this. - 0.03% (2)
item - 0.03% (2)
authorization - 0.03% (2)
guess - 0.03% (2)
injection - 0.03% (2)
volume - 0.03% (2)
components. - 0.03% (2)
serious - 0.03% (2)
doing - 0.03% (2)
days. - 0.03% (2)
solving - 0.03% (2)
understand - 0.03% (2)
round - 0.03% (2)
organization - 0.03% (2)
made - 0.03% (2)
thinking - 0.03% (2)
instance - 0.03% (2)
dbset - 0.03% (2)
successful - 0.03% (2)
employ - 0.03% (2)
logging - 0.03% (2)
angular.js - 0.03% (2)
spas - 0.03% (2)
making - 0.03% (2)
smaller - 0.03% (2)
id. - 0.03% (2)
pattern - 0.03% (2)
knockout.js - 0.03% (2)
goal - 0.03% (2)
overhead - 0.03% (2)
end, - 0.03% (2)
libraries - 0.03% (2)
interested - 0.03% (2)
mostly - 0.03% (2)
sides - 0.03% (2)
install - 0.03% (2)
setup - 0.03% (2)
mvp - 0.03% (2)
community - 0.03% (2)
now. - 0.03% (2)
weaknesses - 0.03% (2)
compare - 0.03% (2)
rails, - 0.03% (2)
prefer - 0.03% (2)
once. - 0.03% (2)
curve - 0.03% (2)
approach. - 0.03% (2)
init(iserviceprovider - 0.03% (2)
_matchservice - 0.03% (2)
choice. - 0.03% (2)
(matchservice)serviceprovider.getservice(typeof(matchservice)); - 0.03% (2)
(usermanager)serviceprovider.getservice(typeof(usermanager)); - 0.03% (2)
_usermanager - 0.03% (2)
selecting - 0.03% (2)
serviceprovider) - 0.03% (2)
these - 0.03% (2)
state - 0.03% (2)
structures - 0.03% (2)
client. - 0.03% (2)
amounts - 0.03% (2)
those - 0.03% (2)
agile - 0.03% (2)
returned - 0.03% (2)
rendered - 0.03% (2)
constant - 0.03% (2)
typical - 0.03% (2)
test. - 0.03% (2)
limited - 0.03% (2)
produce - 0.03% (2)
19, - 0.03% (2)
django, - 0.03% (2)
national - 0.03% (2)
up-to-date - 0.03% (2)
apply. - 0.03% (2)
tasks. - 0.03% (2)
confirmation - 0.03% (2)
planning - 0.03% (2)
interaction - 0.03% (2)
opening - 0.03% (2)
why - 0.03% (2)
handle - 0.03% (2)
decreasing - 0.03% (2)
focus - 0.03% (2)
them. - 0.03% (2)
page. - 0.03% (2)
love - 0.03% (2)
post-back - 0.03% (2)
resolved - 0.03% (2)
sprint. - 0.03% (2)
which - 0.03% (2)
fast - 0.03% (2)
that i - 0.37% (25)
asp.net core - 0.35% (24)
visual studio - 0.32% (22)
of the - 0.29% (20)
is not - 0.26% (18)
a good - 0.26% (18)
here i - 0.25% (17)
web application - 0.23% (16)
there is - 0.22% (15)
to the - 0.22% (15)
cloud storage - 0.21% (14)
front end - 0.19% (13)
can be - 0.19% (13)
for example - 0.18% (12)
studio code - 0.18% (12)
we have - 0.16% (11)
more than - 0.16% (11)
if you - 0.16% (11)
of them - 0.16% (11)
that is - 0.15% (10)
in the - 0.15% (10)
it was - 0.15% (10)
studio 2015 - 0.15% (10)
you can - 0.15% (10)
posted on - 0.15% (10)
an asp.net - 0.15% (10)
the app - 0.15% (10)
to have - 0.13% (9)
not be - 0.13% (9)
based on - 0.13% (9)
the application - 0.13% (9)
working on - 0.13% (9)
storage service - 0.13% (9)
with a - 0.13% (9)
to use - 0.12% (8)
project i - 0.12% (8)
want to - 0.12% (8)
web framework - 0.12% (8)
do not - 0.12% (8)
was not - 0.12% (8)
on the - 0.12% (8)
it has - 0.12% (8)
have a - 0.12% (8)
application that - 0.12% (8)
storage services - 0.12% (8)
structure of - 0.12% (8)
unit test - 0.1% (7)
for an - 0.1% (7)
use in - 0.1% (7)
to database - 0.1% (7)
does not - 0.1% (7)
has been - 0.1% (7)
they are - 0.1% (7)
but it - 0.1% (7)
core project - 0.1% (7)
at the - 0.1% (7)
in asp.net - 0.1% (7)
are not - 0.1% (7)
from a - 0.1% (7)
aware of - 0.1% (7)
an outsource - 0.09% (6)
using cloud - 0.09% (6)
you wan - 0.09% (6)
you are - 0.09% (6)
not very - 0.09% (6)
core i - 0.09% (6)
could be - 0.09% (6)
i think - 0.09% (6)
able to - 0.09% (6)
that i’m - 0.09% (6)
component re-use - 0.09% (6)
can not - 0.09% (6)
i’m working - 0.09% (6)
and is - 0.09% (6)
review structure - 0.09% (6)
too many - 0.07% (5)
some of - 0.07% (5)
in visual - 0.07% (5)
changes in - 0.07% (5)
the project - 0.07% (5)
not all - 0.07% (5)
using a - 0.07% (5)
not work - 0.07% (5)
would be - 0.07% (5)
good architecture - 0.07% (5)
in both - 0.07% (5)
that the - 0.07% (5)
outsource experience - 0.07% (5)
not using - 0.07% (5)
in ubuntu - 0.07% (5)
be able - 0.07% (5)
this is - 0.07% (5)
at least - 0.07% (5)
will be - 0.07% (5)
afshar mohebbi - 0.07% (5)
architecture for - 0.07% (5)
the database - 0.07% (5)
used a - 0.07% (5)
in production - 0.07% (5)
comment on - 0.07% (5)
comments on - 0.07% (5)
on november - 0.07% (5)
when you - 0.07% (5)
solution for - 0.07% (5)
be more - 0.07% (5)
i need - 0.07% (5)
you want - 0.07% (5)
soft delete - 0.07% (5)
not have - 0.07% (5)
that this - 0.07% (5)
database and - 0.07% (5)
in database - 0.07% (5)
high cpu - 0.06% (4)
there are - 0.06% (4)
on software - 0.06% (4)
mohebbi on - 0.06% (4)
to get - 0.06% (4)
project on - 0.06% (4)
the user - 0.06% (4)
that it - 0.06% (4)
that we - 0.06% (4)
many application - 0.06% (4)
of web - 0.06% (4)
asp.net and - 0.06% (4)
exactly same - 0.06% (4)
in different - 0.06% (4)
works good - 0.06% (4)
and it - 0.06% (4)
a team - 0.06% (4)
web development - 0.06% (4)
cpu usage - 0.06% (4)
and even - 0.06% (4)
of work - 0.06% (4)
team members - 0.06% (4)
for it - 0.06% (4)
sanctioned countries - 0.06% (4)
to save - 0.06% (4)
very much - 0.06% (4)
and in - 0.06% (4)
re-use in - 0.06% (4)
another for - 0.06% (4)
for this - 0.06% (4)
and some - 0.06% (4)
service layer - 0.06% (4)
must be - 0.06% (4)
– afshar - 0.06% (4)
used as - 0.06% (4)
this approach - 0.06% (4)
a framework - 0.06% (4)
time for - 0.06% (4)
2016tags asp.net - 0.06% (4)
a base - 0.06% (4)
asp.net mvc - 0.06% (4)
many other - 0.06% (4)
ms office - 0.06% (4)
in this - 0.06% (4)
into a - 0.06% (4)
each other - 0.06% (4)
thing that - 0.06% (4)
what i - 0.06% (4)
web frameworks - 0.06% (4)
think it - 0.06% (4)
this way - 0.06% (4)
than one - 0.06% (4)
have to - 0.06% (4)
same in - 0.06% (4)
one of - 0.06% (4)
that can - 0.06% (4)
and no - 0.06% (4)
other applications - 0.06% (4)
creating a - 0.06% (4)
in application - 0.06% (4)
for many - 0.06% (4)
controllers and - 0.06% (4)
also i - 0.06% (4)
that was - 0.06% (4)
core and - 0.06% (4)
i have - 0.06% (4)
but no - 0.04% (3)
but instead - 0.04% (3)
office online - 0.04% (3)
def is - 0.04% (3)
data access - 0.04% (3)
is used - 0.04% (3)
version of - 0.04% (3)
database models. - 0.04% (3)
applications based - 0.04% (3)
abc and - 0.04% (3)
access to - 0.04% (3)
in other - 0.04% (3)
on reusability - 0.04% (3)
files in - 0.04% (3)
a change - 0.04% (3)
a component - 0.04% (3)
and as - 0.04% (3)
a cloud - 0.04% (3)
hud service - 0.04% (3)
software component - 0.04% (3)
it really - 0.04% (3)
similar to - 0.04% (3)
django and - 0.04% (3)
project layers[/caption] - 0.04% (3)
they were - 0.04% (3)
is done - 0.04% (3)
2016tags asp.net, - 0.04% (3)
application so - 0.04% (3)
file for - 0.04% (3)
entity framework - 0.04% (3)
changes a - 0.04% (3)
and django - 0.04% (3)
development team - 0.04% (3)
is very - 0.04% (3)
really beneficial? - 0.04% (3)
framework to - 0.04% (3)
a file - 0.04% (3)
to upgrade - 0.04% (3)
of project - 0.04% (3)
upgrade a - 0.04% (3)
is base - 0.04% (3)
and pluggability - 0.04% (3)
used by - 0.04% (3)
for no - 0.04% (3)
dialog boxes - 0.04% (3)
than once - 0.04% (3)
client for - 0.04% (3)
about it - 0.04% (3)
forced to - 0.04% (3)
problem is - 0.04% (3)
layer contains - 0.04% (3)
integration with - 0.04% (3)
on review - 0.04% (3)
machine and - 0.04% (3)
time and - 0.04% (3)
is more - 0.04% (3)
my experience - 0.04% (3)
in many - 0.04% (3)
service. it - 0.04% (3)
code in - 0.04% (3)
single page - 0.04% (3)
trying to - 0.04% (3)
a semi - 0.04% (3)
as good - 0.04% (3)
will not - 0.04% (3)
project in - 0.04% (3)
studio 2015, - 0.04% (3)
unit tests - 0.04% (3)
choice is - 0.04% (3)
now that - 0.04% (3)
may 3, - 0.04% (3)
are using - 0.04% (3)
a software - 0.04% (3)
and use - 0.04% (3)
used to - 0.04% (3)
base for - 0.04% (3)
back to - 0.04% (3)
in our - 0.04% (3)
or not. - 0.04% (3)
very much. - 0.04% (3)
when it - 0.04% (3)
a page - 0.04% (3)
business logic - 0.04% (3)
.net developer - 0.04% (3)
be aware - 0.04% (3)
with asp.net - 0.04% (3)
service i - 0.04% (3)
need for - 0.04% (3)
code and - 0.04% (3)
end development - 0.04% (3)
that has - 0.04% (3)
for it. - 0.04% (3)
source code - 0.04% (3)
studio 2015. - 0.04% (3)
and do - 0.04% (3)
member b - 0.04% (3)
our application - 0.04% (3)
be used - 0.04% (3)
finding a - 0.04% (3)
or even - 0.04% (3)
a real - 0.04% (3)
from windows - 0.04% (3)
good front - 0.04% (3)
that works - 0.04% (3)
we had - 0.04% (3)
need to - 0.04% (3)
and ubuntu. - 0.04% (3)
not allow - 0.04% (3)
is that - 0.04% (3)
developing an - 0.04% (3)
time to - 0.04% (3)
pluggability of - 0.04% (3)
it also - 0.04% (3)
and mobile - 0.04% (3)
but when - 0.04% (3)
reusability and - 0.04% (3)
end solution - 0.04% (3)
unit of - 0.04% (3)
as same - 0.04% (3)
the application. - 0.04% (3)
that are - 0.04% (3)
page web - 0.04% (3)
complexity and - 0.04% (3)
that asp.net - 0.04% (3)
in some - 0.04% (3)
is needed - 0.04% (3)
here. posted - 0.04% (3)
decided to - 0.04% (3)
of components - 0.04% (3)
core in - 0.04% (3)
semi single - 0.04% (3)
ubuntu is - 0.04% (3)
development and - 0.04% (3)
sure that - 0.04% (3)
learning curve - 0.03% (2)
but its - 0.03% (2)
web application. - 0.03% (2)
itself as - 0.03% (2)
each app - 0.03% (2)
django has - 0.03% (2)
have less - 0.03% (2)
is posted - 0.03% (2)
to show - 0.03% (2)
the client. - 0.03% (2)
technique is - 0.03% (2)
asp.net application - 0.03% (2)
front end, - 0.03% (2)
not easy - 0.03% (2)
this technique - 0.03% (2)
need a - 0.03% (2)
number of - 0.03% (2)
of using - 0.03% (2)
posted to - 0.03% (2)
the server - 0.03% (2)
setup time - 0.03% (2)
goal is - 0.03% (2)
in new - 0.03% (2)
use previously - 0.03% (2)
they can - 0.03% (2)
be developed - 0.03% (2)
think of - 0.03% (2)
is good - 0.03% (2)
speed of - 0.03% (2)
is high. - 0.03% (2)
also is - 0.03% (2)
on finding - 0.03% (2)
selecting a - 0.03% (2)
compare web - 0.03% (2)
web projects. - 0.03% (2)
be careful. - 0.03% (2)
good integration - 0.03% (2)
many of - 0.03% (2)
it does - 0.03% (2)
operating system - 0.03% (2)
development environment - 0.03% (2)
one thing - 0.03% (2)
from my - 0.03% (2)
it from - 0.03% (2)
them to - 0.03% (2)
in windows - 0.03% (2)
you need - 0.03% (2)
and visual - 0.03% (2)
using .net - 0.03% (2)
unity and - 0.03% (2)
ubuntu machine - 0.03% (2)
a windows - 0.03% (2)
more on - 0.03% (2)
are exactly - 0.03% (2)
then you - 0.03% (2)
that they - 0.03% (2)
referenced from - 0.03% (2)
no matter - 0.03% (2)
at first - 0.03% (2)
service high - 0.03% (2)
to apply. - 0.03% (2)
i decided - 0.03% (2)
caused by - 0.03% (2)
very very - 0.03% (2)
different than - 0.03% (2)
asp.net webform - 0.03% (2)
decade-old asp.net - 0.03% (2)
usage of - 0.03% (2)
problems with - 0.03% (2)
this problem - 0.03% (2)
cs file - 0.03% (2)
would not - 0.03% (2)
prefer to - 0.03% (2)
and run - 0.03% (2)
dependencies to - 0.03% (2)
added to - 0.03% (2)
hosting iis. - 0.03% (2)
cpu usage. - 0.03% (2)
on linux - 0.03% (2)
not sure - 0.03% (2)
to test - 0.03% (2)
cause a - 0.03% (2)
are good - 0.03% (2)
a shared - 0.03% (2)
file to - 0.03% (2)
or your - 0.03% (2)
their own - 0.03% (2)
distributed team - 0.03% (2)
shared space. - 0.03% (2)
file formats - 0.03% (2)
using ms - 0.03% (2)
amounts of - 0.03% (2)
to it. - 0.03% (2)
the file - 0.03% (2)
that django - 0.03% (2)
of it. - 0.03% (2)
good at - 0.03% (2)
job market - 0.03% (2)
i wrote - 0.03% (2)
on selecting - 0.03% (2)
its own - 0.03% (2)
framework based - 0.03% (2)
modifying decade-old - 0.03% (2)
your tablet - 0.03% (2)
security is - 0.03% (2)
on october - 0.03% (2)
android and - 0.03% (2)
office for - 0.03% (2)
have not - 0.03% (2)
a long - 0.03% (2)
other than - 0.03% (2)
both windows - 0.03% (2)
core on - 0.03% (2)
very good - 0.03% (2)
your files - 0.03% (2)
linux user - 0.03% (2)
big problem - 0.03% (2)
android devices - 0.03% (2)
drive. it - 0.03% (2)
specially those - 0.03% (2)
sanctioned countries. - 0.03% (2)
using it - 0.03% (2)
with it. - 0.03% (2)
than other - 0.03% (2)
office online. - 0.03% (2)
you to - 0.03% (2)
one for - 0.03% (2)
there were - 0.03% (2)
resolved with - 0.03% (2)
of current - 0.03% (2)
to current - 0.03% (2)
on this - 0.03% (2)
tasks were - 0.03% (2)
were not - 0.03% (2)
database table - 0.03% (2)
as project - 0.03% (2)
i mean - 0.03% (2)
and was - 0.03% (2)
than 1 - 0.03% (2)
am trying - 0.03% (2)
web and - 0.03% (2)
serviceprovider) { - 0.03% (2)
_usermanager = - 0.03% (2)
void init(iserviceprovider - 0.03% (2)
it can - 0.03% (2)
code for - 0.03% (2)
(usermanager)serviceprovider.getservice(typeof(usermanager)); _matchservice - 0.03% (2)
= (matchservice)serviceprovider.getservice(typeof(matchservice)); - 0.03% (2)
have been - 0.03% (2)
recently i - 0.03% (2)
be simply - 0.03% (2)
as you - 0.03% (2)
adding to - 0.03% (2)
more up-to-date - 0.03% (2)
the team - 0.03% (2)
a technical - 0.03% (2)
one in - 0.03% (2)
from scrum - 0.03% (2)
even small - 0.03% (2)
review on - 0.03% (2)
and here. - 0.03% (2)
i guess - 0.03% (2)
one. we - 0.03% (2)
experience creating - 0.03% (2)
april 23, - 0.03% (2)
needed to - 0.03% (2)
not in - 0.03% (2)
with different - 0.03% (2)
member a - 0.03% (2)
in several - 0.03% (2)
all team - 0.03% (2)
was causing - 0.03% (2)
see it - 0.03% (2)
b could - 0.03% (2)
works are - 0.03% (2)
solve the - 0.03% (2)
try to - 0.03% (2)
by thinking - 0.03% (2)
each single - 0.03% (2)
class for - 0.03% (2)
not aware - 0.03% (2)
dirty checking - 0.03% (2)
services are - 0.03% (2)
from user. - 0.03% (2)
with data - 0.03% (2)
save it - 0.03% (2)
while you - 0.03% (2)
layer is - 0.03% (2)
layer. presentation - 0.03% (2)
layers[/caption]asp.net core - 0.03% (2)
project layers[/caption]asp.net - 0.03% (2)
they do - 0.03% (2)
apis are - 0.03% (2)
on developing - 0.03% (2)
application from - 0.03% (2)
experience – - 0.03% (2)
applications review - 0.03% (2)
application an - 0.03% (2)
have used - 0.03% (2)
wrote about - 0.03% (2)
and web - 0.03% (2)
web apis - 0.03% (2)
not like - 0.03% (2)
have 3 - 0.03% (2)
in turn - 0.03% (2)
each other. - 0.03% (2)
least one - 0.03% (2)
one time - 0.03% (2)
as database - 0.03% (2)
also have - 0.03% (2)
application itself. - 0.03% (2)
the database. - 0.03% (2)
for each - 0.03% (2)
a separate - 0.03% (2)
classes that - 0.03% (2)
good idea. - 0.03% (2)
but now - 0.03% (2)
validations and - 0.03% (2)
same as - 0.03% (2)
changes to - 0.03% (2)
late to - 0.03% (2)
call savechanges() - 0.03% (2)
and all - 0.03% (2)
models and - 0.03% (2)
duplicate values - 0.03% (2)
is sent - 0.03% (2)
work as - 0.03% (2)
works on - 0.03% (2)
the system - 0.03% (2)
to implement - 0.03% (2)
but use - 0.03% (2)
many projects - 0.03% (2)
them are - 0.03% (2)
i need. - 0.03% (2)
is based - 0.03% (2)
to share - 0.03% (2)
exists in - 0.03% (2)
a complete - 0.03% (2)
all together - 0.03% (2)
is the - 0.03% (2)
is forced - 0.03% (2)
is called - 0.03% (2)
asp.net that - 0.03% (2)
specially in - 0.03% (2)
it would - 0.03% (2)
checking mechanism - 0.03% (2)
of development - 0.03% (2)
allow a - 0.03% (2)
and services - 0.03% (2)
roles in - 0.03% (2)
of this - 0.03% (2)
3, 2017tags - 0.03% (2)
new projects. - 0.03% (2)
previously developed - 0.03% (2)
on it. - 0.03% (2)
many companies - 0.03% (2)
an app - 0.03% (2)
it. but - 0.03% (2)
for main - 0.03% (2)
where that - 0.03% (2)
pages can - 0.03% (2)
server then - 0.03% (2)
to server, - 0.03% (2)
and also - 0.03% (2)
and need - 0.03% (2)
pages will - 0.03% (2)
back end - 0.03% (2)
application with - 0.03% (2)
so need - 0.03% (2)
except for - 0.03% (2)
and ajax - 0.03% (2)
several projects - 0.03% (2)
you must - 0.03% (2)
you have - 0.03% (2)
a re-usable - 0.03% (2)
for the - 0.03% (2)
as others - 0.03% (2)
the reason - 0.03% (2)
this application - 0.03% (2)
in middle - 0.03% (2)
19, 2016tags - 0.03% (2)
and when - 0.03% (2)
could have - 0.03% (2)
we can - 0.03% (2)
if every - 0.03% (2)
done via - 0.03% (2)
and if - 0.03% (2)
is impossible - 0.03% (2)
others are - 0.03% (2)
use windows - 0.03% (2)
services to - 0.03% (2)
of asp.net - 0.03% (2)
so main - 0.03% (2)
with large - 0.03% (2)
type of - 0.03% (2)
be done - 0.03% (2)
and very - 0.03% (2)
many applications - 0.03% (2)
dealing with - 0.03% (2)
been used - 0.03% (2)
review its - 0.03% (2)
and many - 0.03% (2)
large amount - 0.03% (2)
of database - 0.03% (2)
this upgrade - 0.03% (2)
abc to - 0.03% (2)
performance issues - 0.03% (2)
amount of - 0.03% (2)
time saving - 0.03% (2)
but they - 0.03% (2)
very popular - 0.03% (2)
dependency injection - 0.03% (2)
interfaces are - 0.03% (2)
programming against - 0.03% (2)
than a - 0.03% (2)
so many - 0.03% (2)
project that - 0.03% (2)
each record - 0.03% (2)
them in - 0.03% (2)
database records - 0.03% (2)
interface that - 0.03% (2)
web applications - 0.03% (2)
for asp.net - 0.03% (2)
a project - 0.03% (2)
to review - 0.03% (2)
like to - 0.03% (2)
november 26, - 0.03% (2)
very similar - 0.03% (2)
both web - 0.03% (2)
and complex - 0.03% (2)
that contains - 0.03% (2)
for web - 0.03% (2)
to linux - 0.03% (2)
and have - 0.03% (2)
one operation - 0.03% (2)
visual studio code - 0.18% (12)
visual studio 2015 - 0.15% (10)
cloud storage services - 0.12% (8)
an asp.net core - 0.12% (8)
it is not - 0.1% (7)
a web application - 0.1% (7)
using cloud storage - 0.09% (6)
application that i’m - 0.09% (6)
that i’m working - 0.09% (6)
i’m working on - 0.09% (6)
review structure of - 0.09% (6)
web application that - 0.09% (6)
structure of a - 0.09% (6)
in visual studio - 0.07% (5)
good architecture for - 0.07% (5)
some of them - 0.07% (5)
an outsource experience - 0.07% (5)
asp.net core application - 0.07% (5)
architecture for an - 0.07% (5)
a good architecture - 0.07% (5)
for an asp.net - 0.07% (5)
be able to - 0.06% (4)
is a good - 0.06% (4)
i think it - 0.06% (4)
there is no - 0.06% (4)
– afshar mohebbi - 0.06% (4)
and it is - 0.06% (4)
afshar mohebbi on - 0.06% (4)
it was not - 0.04% (3)
and django and - 0.04% (3)
that can be - 0.04% (3)
be used as - 0.04% (3)
a framework to - 0.04% (3)
re-use in asp.net - 0.04% (3)
pluggability of components - 0.04% (3)
on software component - 0.04% (3)
to the app - 0.04% (3)
to be able - 0.04% (3)
is it really - 0.04% (3)
reusability and pluggability - 0.04% (3)
as a base - 0.04% (3)
for many other - 0.04% (3)
a cloud storage - 0.04% (3)
based on it - 0.04% (3)
many other applications - 0.04% (3)
to be used - 0.04% (3)
developing an asp.net - 0.04% (3)
too many changes - 0.04% (3)
could be more - 0.04% (3)
a comment on - 0.04% (3)
creating a framework - 0.04% (3)
core project on - 0.04% (3)
windows and ubuntu. - 0.04% (3)
on reusability and - 0.04% (3)
for a semi - 0.04% (3)
single page web - 0.04% (3)
software component re-use - 0.04% (3)
can not be - 0.04% (3)
front end solution - 0.04% (3)
finding a good - 0.04% (3)
it really beneficial? - 0.04% (3)
django and is - 0.04% (3)
on review structure - 0.04% (3)
is not very - 0.04% (3)
project on ubuntu - 0.04% (3)
in asp.net and - 0.04% (3)
base for many - 0.04% (3)
in ubuntu is - 0.04% (3)
visual studio 2015. - 0.04% (3)
front end development - 0.04% (3)
visual studio 2015, - 0.04% (3)
a base for - 0.04% (3)
framework to be - 0.04% (3)
you want to - 0.04% (3)
data access layer - 0.04% (3)
be aware of - 0.04% (3)
used as a - 0.04% (3)
that you can - 0.03% (2)
and ajax calls - 0.03% (2)
not very good - 0.03% (2)
use previously developed - 0.03% (2)
a good choice - 0.03% (2)
is to use - 0.03% (2)
web framework based - 0.03% (2)
them compare web - 0.03% (2)
to server, then - 0.03% (2)
pages can not - 0.03% (2)
have more than - 0.03% (2)
to the server - 0.03% (2)
compare web frameworks - 0.03% (2)
a windows machine - 0.03% (2)
high cpu usage. - 0.03% (2)
service high cpu - 0.03% (2)
and visual studio - 0.03% (2)
good integration with - 0.03% (2)
not work as - 0.03% (2)
hud service high - 0.03% (2)
19, 2016tags asp.net - 0.03% (2)
posted on may - 0.03% (2)
has been changed - 0.03% (2)
that we have - 0.03% (2)
modifying decade-old asp.net - 0.03% (2)
is not as - 0.03% (2)
code and visual - 0.03% (2)
on the internet - 0.03% (2)
posted on october - 0.03% (2)
drive. it has - 0.03% (2)
cloud storage system - 0.03% (2)
framework based on - 0.03% (2)
very good at - 0.03% (2)
asp.net core on - 0.03% (2)
they do not - 0.03% (2)
exactly same in - 0.03% (2)
this application is - 0.03% (2)
both windows and - 0.03% (2)
selecting a web - 0.03% (2)
is forced to - 0.03% (2)
a good idea. - 0.03% (2)
prefer to use - 0.03% (2)
used to use - 0.03% (2)
changes to the - 0.03% (2)
in the code - 0.03% (2)
one time for - 0.03% (2)
it is more - 0.03% (2)
serviceprovider) { _usermanager - 0.03% (2)
there were tasks - 0.03% (2)
and some of - 0.03% (2)
on a good - 0.03% (2)
= (matchservice)serviceprovider.getservice(typeof(matchservice)); } - 0.03% (2)
= (usermanager)serviceprovider.getservice(typeof(usermanager)); _matchservice - 0.03% (2)
one thing that - 0.03% (2)
is sent to - 0.03% (2)
outsource experience – - 0.03% (2)
that asp.net core - 0.03% (2)
experience – afshar - 0.03% (2)
other applications review - 0.03% (2)
application an outsource - 0.03% (2)
experience creating a - 0.03% (2)
i wrote about - 0.03% (2)
do not like - 0.03% (2)
to database and - 0.03% (2)
but when it - 0.03% (2)
not a good - 0.03% (2)
layer. presentation layer - 0.03% (2)
project layers[/caption]asp.net core - 0.03% (2)
many changes in - 0.03% (2)
it was better - 0.03% (2)
you can use - 0.03% (2)
asp.net that is - 0.03% (2)
it would be - 0.03% (2)
in new projects. - 0.03% (2)
controllers and services - 0.03% (2)
but i think - 0.03% (2)
is based on - 0.03% (2)
of them are - 0.03% (2)
others are using - 0.03% (2)
is the reason - 0.03% (2)
there is an - 0.03% (2)
of the application - 0.03% (2)
what i need - 0.03% (2)
do not allow - 0.03% (2)
the application so - 0.03% (2)
more than once. - 0.03% (2)
to review its - 0.03% (2)
are not very - 0.03% (2)
here and here. - 0.03% (2)
1 day later - 0.03% (2)
is that the - 0.03% (2)
has been used - 0.03% (2)
large amount of - 0.03% (2)
think it is - 0.03% (2)
and another for - 0.03% (2)
as others are - 0.03% (2)
be sure that - 0.03% (2)
i want to - 0.03% (2)
in middle of - 0.03% (2)

Here you can find chart of all your popular one, two and three word phrases. Google and others search engines means your page is about words you use frequently.

Copyright © 2015-2016 hupso.pl. All rights reserved. FB | +G | Twitter

Hupso.pl jest serwisem internetowym, w którym jednym kliknieciem możesz szybko i łatwo sprawdź stronę www pod kątem SEO. Oferujemy darmowe pozycjonowanie stron internetowych oraz wycena domen i stron internetowych. Prowadzimy ranking polskich stron internetowych oraz ranking stron alexa.